scripts/build_knowledge_vault.py

#!/usr/bin/env python3
"""CORTEX knowledge-vault builder v3 — owner directive execution:
clone approved skill repos -> /modules/, AST-extract -> /symbols/schemas/,
sha256 manifests, merge real entries into symbol_evolution_index.json, upload tree.
"""
import ast, hashlib, json, os, subprocess, time

REPO = "Johnny5b/portable-ai-runner"
BASE = "/work"
MODULES = os.path.join(BASE, "modules")
SCHEMAS = os.path.join(BASE, "schemas_out")

SKILLS = [
    ("EVO_TREE:TINYVERSE",    "TinyverseGP",          "https://github.com/GPBench/TinyverseGP.git"),
    ("EVO_OPT:DEAP",          "deap",                 "https://github.com/deap/deap.git"),
    ("EVO_NEURO:EVOTORCH",    "evotorch",             "https://github.com/nnaisense/evotorch.git"),
    ("AGENT:EVA",             "eva-evolutional-agent","https://github.com/arturkorb3/eva-evolutional-agent.git"),
    ("RHETORIC:RST",          "isanlp_rst",           "https://github.com/tchewik/isanlp_rst.git"),
    ("RHETORIC:ARG_MINER",    "e2e-microtexts",       "https://github.com/tchewik/e2e-microtexts.git"),
]

MAX_UPLOAD_BYTES = 20 * 1024 * 1024
MAX_PARSE_BYTES = 300 * 1024

def sh(cmd, cwd=None):
    """cmd: list -> no shell; str -> shell. Never mix."""
    if isinstance(cmd, list):
        r = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, timeout=900)
    else:
        r = subprocess.run(cmd, shell=True, cwd=cwd, capture_output=True, text=True, timeout=900)
    return r.returncode, (r.stdout or "") + (r.stderr or "")

def sha256(path):
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(1 << 20), b""):
            h.update(chunk)
    return h.hexdigest()

def clone(url, dest):
    if os.path.exists(dest):
        return sh("git rev-parse HEAD", cwd=dest)[1].strip()
    code, out = sh(["git", "clone", "--depth", "1", url, dest])
    if code != 0:
        raise RuntimeError(f"clone failed {url}: {out[-300:]}")
    return sh("git rev-parse HEAD", cwd=dest)[1].strip()

def walk_files(root):
    for dirpath, _, files in os.walk(root):
        if ".git" in dirpath:
            continue
        for fn in files:
            yield os.path.join(dirpath, fn)

def parse_module(name, root):
    fns, classes, nfiles = [], [], 0
    for p in walk_files(root):
        if not p.endswith(".py") or os.path.getsize(p) > MAX_PARSE_BYTES:
            continue
        nfiles += 1
        try:
            src = open(p, encoding="utf-8", errors="ignore").read()
            tree = ast.parse(src)
        except SyntaxError:
            continue
        rel = os.path.relpath(p, root)
        for node in tree.body:
            if isinstance(node, ast.FunctionDef):
                fns.append({"file": rel, "name": node.name,
                            "args": [a.arg for a in node.args.args],
                            "doc": (ast.get_docstring(node) or "")[:160]})
            elif isinstance(node, ast.ClassDef):
                ms = [m.name for m in node.body if isinstance(m, ast.FunctionDef)]
                classes.append({"file": rel, "name": node.name, "methods": ms,
                                "doc": (ast.get_docstring(node) or "")[:160]})
    return {"module": name, "files_parsed": nfiles, "functions": fns, "classes": classes}, fns, classes

def templates_md(name, fns, classes, commit):
    L = [f"# {name} — execution schema",
         f"upstream commit: `{commit}` | extractor: stdlib `ast` (no the banned library (owner directive 2026-09-18))",
         f"{len(fns)} functions, {len(classes)} classes parsed", "",
         "## Function signatures"]
    for f in fns[:80]:
        sig = ", ".join(f["args"]) or "()"
        L.append(f"- `{f['name']}({sig})` — {f['file']}" + (f" · {f['doc']}" if f["doc"] else ""))
    if len(fns) > 80:
        L.append(f"- … and {len(fns) - 80} more (see {name}.json)")
    L += ["", "## Classes"]
    for c in classes[:60]:
        L.append(f"- `{c['name']}` ({len(c['methods'])} methods) — {c['file']}")
    return "\n".join(L) + "\n"

def file_manifest(root):
    out = {}
    for p in walk_files(root):
        if os.path.getsize(p) <= MAX_UPLOAD_BYTES:
            out[os.path.relpath(p, root)] = sha256(p)
    return out

def main():
    from huggingface_hub import HfApi, hf_hub_download
    token = os.environ["HF_TOKEN"]
    api = HfApi(token=token)
    os.makedirs(MODULES, exist_ok=True)
    os.makedirs(SCHEMAS, exist_ok=True)
    entries = {}
    for sym, name, url in SKILLS:
        t0 = time.time()
        dest = os.path.join(MODULES, name)
        commit = sh("git rev-parse HEAD", cwd=dest)[1].strip() if os.path.exists(dest) else clone(url, dest)
        parsed, fns, classes = parse_module(name, dest)
        json.dump(parsed, open(os.path.join(SCHEMAS, f"{name}.json"), "w"), indent=1)
        open(os.path.join(SCHEMAS, f"{name}.md"), "w").write(templates_md(name, fns, classes, commit))
        man = file_manifest(dest)
        json.dump({"module": name, "commit": commit, "files": len(man), "sha256": man},
                  open(os.path.join(SCHEMAS, f"{name}.manifest.json"), "w"))
        print(f"[OK] {name} symbol:{sym} commit={commit[:12]} files={len(man)} "
              f"parsed={len(fns)}f/{len(classes)}c in {time.time() - t0:.0f}s", flush=True)
        entries[name] = {"symbol": f"symbol:{sym}", "type": "skill_module",
                         "path": f"modules/{name}", "upstream": url, "commit": commit,
                         "schema_md": f"symbols/schemas/{name}.md",
                         "schema_json": f"symbols/schemas/{name}.json",
                         "manifest": f"symbols/schemas/{name}.manifest.json",
                         "status": "active-mirror"}

    idx_path = hf_hub_download(REPO, "symbols/symbol_evolution_index.json",
                               repo_type="dataset", token=token)
    idx = json.load(open(idx_path))
    idx.setdefault("symbols", {})
    for k, v in entries.items():
        idx["symbols"][f"symbol:MODULE:{k}"] = v
    idx["last_build"] = {"ts": time.time(), "builder": "scripts/build_knowledge_vault.py v3",
                         "modules": sorted(entries)}
    json.dump(idx, open(idx_path, "w"), indent=2)

    for name in entries:
        api.upload_folder(repo_id=REPO, repo_type="dataset",
                          folder_path=os.path.join(MODULES, name),
                          path_in_repo=f"modules/{name}",
                          commit_message=f"CORTEX vault: module {name} (active-mirror)")
        print(f"[UP] modules/{name}", flush=True)
    api.upload_folder(repo_id=REPO, repo_type="dataset", folder_path=SCHEMAS,
                      path_in_repo="symbols/schemas",
                      commit_message="CORTEX vault: AST-extracted schemas")
    api.upload_file(repo_id=REPO, repo_type="dataset", path_or_fileobj=idx_path,
                    path_in_repo="symbols/symbol_evolution_index.json",
                    commit_message="CORTEX vault: symbol index with sha256 manifests")
    print(f"BUILD DONE modules={len(entries)}", flush=True)

if __name__ == "__main__":
    main()