scripts/generate_corpus.py

#!/usr/bin/env python3
"""Build a public Hermes-agentic SFT corpus (synthetic, Apache-2.0).

Teaches models to call Hermes tools correctly and STOP — not to loop.
No third-party distill, no live home-directory traces.
"""
from __future__ import annotations

import hashlib
import json
import random
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
DATA = ROOT / "data"
RNG = random.Random(20260813)

TOOLS = {
    "terminal": {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "Execute a shell command. Do not repeat a command whose output you already have.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {"type": "string", "description": "The command to execute"},
                    "timeout": {"type": "integer", "minimum": 1},
                    "workdir": {"type": "string"},
                },
                "required": ["command"],
            },
        },
    },
    "read_file": {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read a text file.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "offset": {"type": "integer"},
                    "limit": {"type": "integer"},
                },
                "required": ["path"],
            },
        },
    },
    "search_files": {
        "type": "function",
        "function": {
            "name": "search_files",
            "description": "Search file contents or names.",
            "parameters": {
                "type": "object",
                "properties": {
                    "pattern": {"type": "string"},
                    "path": {"type": "string"},
                    "target": {"type": "string", "enum": ["content", "files"]},
                },
                "required": ["pattern"],
            },
        },
    },
    "write_file": {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Write a text file. Overwrites the entire file.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "content": {"type": "string"},
                },
                "required": ["path", "content"],
            },
        },
    },
    "web_search": {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the public web. One good search is enough; do not retry an identical query.",
            "parameters": {
                "type": "object",
                "properties": {"query": {"type": "string"}, "limit": {"type": "integer"}},
                "required": ["query"],
            },
        },
    },
    "web_extract": {
        "type": "function",
        "function": {
            "name": "web_extract",
            "description": "Fetch a URL as text. Not a search engine.",
            "parameters": {
                "type": "object",
                "properties": {"urls": {"type": "array", "items": {"type": "string"}}},
                "required": ["urls"],
            },
        },
    },
    "todo": {
        "type": "function",
        "function": {
            "name": "todo",
            "description": "Write or update an in-session task list.",
            "parameters": {
                "type": "object",
                "properties": {
                    "todos": {"type": "array"},
                    "merge": {"type": "boolean"},
                },
                "required": ["todos"],
            },
        },
    },
}

CORE = ["terminal", "read_file", "search_files", "write_file", "web_search"]


def tc(i: str, name: str, args: dict) -> dict:
    return {
        "id": i,
        "type": "function",
        "function": {"name": name, "arguments": json.dumps(args, separators=(",", ":"))},
    }


def row(tag: str, messages: list, tool_names: list[str], extra: str = "") -> dict:
    seq = next_seq()
    blob = json.dumps({"tag": tag, "messages": messages, "x": extra, "n": seq}, sort_keys=True)
    rid = hashlib.sha1(blob.encode()).hexdigest()[:12]
    return {
        "id": f"{tag}-{seq:04d}-{rid}",
        "tag": tag,
        "source": "synthetic-hermes-v1",
        "license": "apache-2.0",
        "messages": messages,
        "tools": [TOOLS[n] for n in tool_names],
    }


_SEQ = 0


def next_seq() -> int:
    global _SEQ
    _SEQ += 1
    return _SEQ


PROJECTS = [
    ("demo", ["README.md", "src/app.py", "data/config.yaml"], "8084"),
    ("api", ["README.md", "app/main.py", "config/settings.toml"], "8000"),
    ("bot", ["README.md", "hermes_bot.py", "env.example"], "8083"),
    ("web", ["README.md", "frontend/index.html", "nginx.conf"], "443"),
    ("ml", ["README.md", "train.py", "configs/base.yaml"], "6006"),
    ("cli", ["README.md", "src/cli.py", "pyproject.toml"], "0"),
    ("gate", ["README.md", "hermes_loop_gate.py", "docs/serve.md"], "8084"),
    ("agent", ["README.md", "agent/loop.py", "prompts/system.md"], "11434"),
    ("svc", ["README.md", "service.py", "deploy/compose.yml"], "9090"),
    ("lib", ["README.md", "src/lib.rs", "Cargo.toml"], "0"),
]

QUERIES = [
    ("latest stable Python 3", "Python 3.14.6 is the latest stable release.", "3.14.6"),
    ("Hermes Agent tool calling", "Hermes Agent uses OpenAI-style tools= / tool_calls.", "OpenAI tool_calls"),
    ("Muse Glimmer context length", "Muse Glimmer documents a 131K context window.", "131K"),
    ("llama.cpp server OpenAI API", "llama-server exposes POST /v1/chat/completions.", "/v1/chat/completions"),
    ("current UTC date", "The cited page lists Thursday, 13 August 2026.", "13 August 2026"),
]


def stop_ls() -> dict:
    name, files, _ = RNG.choice(PROJECTS)
    listing = "\n".join(files) + "\n"
    return row(
        "stop",
        [
            {"role": "user", "content": f"List files in the {name} workspace. Then stop and name them. Do not list again."},
            {"role": "assistant", "tool_calls": [tc("c1", "terminal", {"command": RNG.choice(["ls", "ls -la", "dir"])})]},
            {"role": "tool", "tool_call_id": "c1", "content": listing},
            {"role": "assistant", "content": "Files: " + ", ".join(files) + "."},
        ],
        ["terminal", "search_files", "read_file"],
        name,
    )


def stop_read() -> dict:
    name, files, port = RNG.choice(PROJECTS)
    path = files[-1]
    return row(
        "stop",
        [
            {"role": "user", "content": f"Read {path} and tell me the port. One read is enough."},
            {"role": "assistant", "tool_calls": [tc("c1", "read_file", {"path": path})]},
            {"role": "tool", "tool_call_id": "c1", "content": f"port = {port}\nhost = 127.0.0.1\n"},
            {"role": "assistant", "content": f"The port is {port}."},
        ],
        ["read_file", "terminal"],
        path,
    )


def stop_search() -> dict:
    name, files, port = RNG.choice(PROJECTS)
    hit = files[-1]
    return row(
        "stop",
        [
            {"role": "user", "content": f"Find which file sets the listen port in {name}. Then stop."},
            {"role": "assistant", "tool_calls": [tc("c1", "search_files", {"pattern": "port", "target": "content"})]},
            {"role": "tool", "tool_call_id": "c1", "content": f"{hit}:1:port = {port}"},
            {"role": "assistant", "content": f"{hit} sets port {port}."},
        ],
        ["search_files", "read_file"],
        hit,
    )


def stop_write() -> dict:
    path = RNG.choice(["notes.txt", "out/ok.txt", "STATUS.md"])
    word = RNG.choice(["ready", "ok", "done"])
    return row(
        "stop",
        [
            {"role": "user", "content": f"Write {path} containing just '{word}'. Then stop."},
            {"role": "assistant", "tool_calls": [tc("c1", "write_file", {"path": path, "content": word + "\n"})]},
            {"role": "tool", "tool_call_id": "c1", "content": f"wrote {path} ({len(word)+1} bytes)"},
            {"role": "assistant", "content": f"Wrote {path}."},
        ],
        ["write_file", "terminal"],
        path,
    )


def stop_web() -> dict:
    q, snippet, ans = RNG.choice(QUERIES)
    return row(
        "stop",
        [
            {"role": "user", "content": f"Search the web once for {q}. Then answer briefly. Do not extract extra URLs."},
            {"role": "assistant", "tool_calls": [tc("c1", "web_search", {"query": q})]},
            {"role": "tool", "tool_call_id": "c1", "content": f"1. {snippet} — https://example.test/a"},
            {"role": "assistant", "content": ans},
        ],
        ["web_search", "web_extract"],
        q,
    )


def stop_todo() -> dict:
    return row(
        "stop",
        [
            {"role": "user", "content": "Plan a 3-step audit of this repo as a todo list. Do not start the audit."},
            {
                "role": "assistant",
                "tool_calls": [
                    tc(
                        "c1",
                        "todo",
                        {
                            "todos": [
                                {"id": "1", "content": "List top-level files", "status": "pending"},
                                {"id": "2", "content": "Read the README", "status": "pending"},
                                {"id": "3", "content": "Note open questions", "status": "pending"},
                            ]
                        },
                    )
                ],
            },
            {"role": "tool", "tool_call_id": "c1", "content": "ok, 3 todos"},
            {"role": "assistant", "content": "Planned three steps: list files, read README, note questions. Not starting yet."},
        ],
        ["todo", "web_search", "terminal"],
        "todo",
    )


def no_tool_math() -> dict:
    a, b = RNG.randint(11, 40), RNG.randint(11, 40)
    return row(
        "no_tool",
        [
            {"role": "user", "content": f"What is {a} times {b}? Reply with just the number. Do not use tools."},
            {"role": "assistant", "content": str(a * b)},
        ],
        CORE,
        f"{a}x{b}",
    )


def no_tool_def() -> dict:
    q, a = RNG.choice(
        [
            ("In one sentence, what is a JSON schema? Do not run shell commands.", "A JSON Schema is a JSON document that declares the shape, types, and constraints of other JSON data."),
            ("What is OpenAI tool calling? One sentence. No tools.", "The model emits structured tool_calls; the client runs the function and returns a tool message."),
            ("What does HIT_CAP mean in an agent bench? No tools.", "The model kept calling tools until the turn limit with no user-facing answer."),
        ]
    )
    return row("no_tool", [{"role": "user", "content": q}, {"role": "assistant", "content": a}], CORE, q[:40])


def recover_missing() -> dict:
    name, files, port = RNG.choice(PROJECTS)
    bad, good = "config.yaml", files[-1]
    return row(
        "recover",
        [
            {"role": "user", "content": f"Read {bad} and tell me the port."},
            {"role": "assistant", "tool_calls": [tc("c1", "read_file", {"path": bad})]},
            {"role": "tool", "tool_call_id": "c1", "content": f"ERROR: File not found: {bad}. Try {good}"},
            {"role": "assistant", "tool_calls": [tc("c2", "read_file", {"path": good})]},
            {"role": "tool", "tool_call_id": "c2", "content": f"port = {port}\n"},
            {"role": "assistant", "content": f"{bad} is missing. {good} sets port {port}."},
        ],
        ["read_file", "search_files"],
        good,
    )


def recover_perm() -> dict:
    cmd = RNG.choice(["cat /etc/secret.conf", "cat /root/.env"])
    return row(
        "recover",
        [
            {"role": "user", "content": f"Show me the contents using the terminal: {cmd}"},
            {"role": "assistant", "tool_calls": [tc("c1", "terminal", {"command": cmd})]},
            {"role": "tool", "tool_call_id": "c1", "content": "ERROR: permission denied"},
            {"role": "assistant", "content": "That path is not readable here (permission denied). I will not keep retrying the same command."},
        ],
        ["terminal", "read_file"],
        cmd,
    )


def dead_web() -> dict:
    q, _, _ = RNG.choice(QUERIES)
    err = RNG.choice(
        [
            "ERROR: search backend unavailable (ddgs package is not installed).",
            "ERROR: FIRECRAWL_API_KEY is not set; extract/search backend unavailable.",
            "ERROR: DuckDuckGo (ddgs) is a search-only backend and cannot fetch arbitrary URLs.",
        ]
    )
    return row(
        "dead_tool",
        [
            {"role": "user", "content": f"Search the web for {q}."},
            {"role": "assistant", "tool_calls": [tc("c1", "web_search", {"query": q})]},
            {"role": "tool", "tool_call_id": "c1", "content": err},
            {
                "role": "assistant",
                "content": "Web search is not available on this instance. I will not retry the same call. Configure a search backend (for example ddgs) if you want me to look it up.",
            },
        ],
        ["web_search", "web_extract"],
        err[:40],
    )


def dead_extract() -> dict:
    return row(
        "dead_tool",
        [
            {"role": "user", "content": "Search once for the latest stable Python 3, then answer. Do not fetch extra pages if extract fails."},
            {"role": "assistant", "tool_calls": [tc("c1", "web_search", {"query": "Python 3 latest stable version"})]},
            {"role": "tool", "tool_call_id": "c1", "content": "1. Python 3.14.6 is the latest stable release."},
            {"role": "assistant", "content": "Latest stable is 3.14.6."},
        ],
        ["web_search", "web_extract"],
        "no-extract",
    )


def schema_fix() -> dict:
    return row(
        "schema",
        [
            {"role": "user", "content": "Run `pwd` using the terminal tool, then report the result."},
            {"role": "assistant", "tool_calls": [tc("c1", "terminal", {"command": "pwd"})]},
            {"role": "tool", "tool_call_id": "c1", "content": "/workspace/demo\n"},
            {"role": "assistant", "content": "pwd → /workspace/demo"},
        ],
        ["terminal"],
        "pwd",
    )


def schema_not_code() -> dict:
    return row(
        "schema",
        [
            {"role": "user", "content": "Use the terminal to echo hello. Put the shell command in the command field, not a Python code field."},
            {"role": "assistant", "tool_calls": [tc("c1", "terminal", {"command": "echo hello"})]},
            {"role": "tool", "tool_call_id": "c1", "content": "hello\n"},
            {"role": "assistant", "content": "hello"},
        ],
        ["terminal"],
        "echo",
    )


BUILDERS = [
    (stop_ls, 280),
    (stop_read, 260),
    (stop_search, 180),
    (stop_write, 140),
    (stop_web, 180),
    (stop_todo, 80),
    (no_tool_math, 160),
    (no_tool_def, 80),
    (recover_missing, 160),
    (recover_perm, 80),
    (dead_web, 160),
    (dead_extract, 80),
    (schema_fix, 80),
    (schema_not_code, 60),
]


def main() -> None:
    rows = []
    seen = set()
    for fn, n in BUILDERS:
        got = 0
        spins = 0
        while got < n and spins < n * 20:
            spins += 1
            r = fn()
            if r["id"] in seen:
                continue
            seen.add(r["id"])
            rows.append(r)
            got += 1
    RNG.shuffle(rows)
    n_val = max(80, len(rows) // 10)
    val = rows[:n_val]
    train = rows[n_val:]
    DATA.mkdir(parents=True, exist_ok=True)
    for name, part in ("train.jsonl", train), ("validation.jsonl", val):
        path = DATA / name
        with path.open("w", encoding="utf-8") as f:
            for r in part:
                f.write(json.dumps(r, ensure_ascii=False) + "\n")
    tags = {}
    for r in rows:
        tags[r["tag"]] = tags.get(r["tag"], 0) + 1
    print(json.dumps({"n": len(rows), "train": len(train), "validation": len(val), "tags": tags}, indent=2))


if __name__ == "__main__":
    main()