okstra 0.130.4 → 0.131.0

package/src/cli-registry.mjs

@@ -236,13 +236,6 @@ export const COMMAND_REGISTRY = [
     category: "introspection",
     summary: ["Manage cross-project okstra tasks"],
   },
-  {
-    name: "graphify",
-    module: "./commands/graphify.mjs",
-    export: "run",
-    category: "introspection",
-    summary: ["Build/query a .okstra-scoped knowledge graph"],
-  },
   {
     name: "worktree-lookup",
     module: "./commands/execute/worktree-lookup.mjs",

package/src/commands/lifecycle/doctor.mjs

@@ -113,14 +113,6 @@ async function checkPythonImport(moduleName, pythonpath) {
   return { ok: true, detail: `${moduleName} importable` };
 }
 
-async function checkGraphifyVendor() {
-  const r = await runPythonSnippet({ script: "import okstra_vendor, graphify, networkx" });
-  if (r.code !== 0) {
-    return { ok: false, detail: `vendored graphify import failed: ${r.stderr.trim().split("\n").pop()}` };
-  }
-  return { ok: true, detail: "okstra_vendor, graphify, networkx importable" };
-}
-
 async function checkBashEntry(binDir, name) {
   const p = join(binDir, name);
   if (!(await fileExists(p))) return { ok: false, detail: `missing ${p}` };
@@ -226,7 +218,6 @@ export async function run(args) {
     await check("python3", checkPython3),
     await check("okstra_project import", () => checkPythonImport("okstra_project", paths.pythonpath)),
     await check("okstra_ctl import", () => checkPythonImport("okstra_ctl", paths.pythonpath)),
-    await check("graphify vendor import", checkGraphifyVendor),
     await check("agents dir", async () =>
       (await fileExists(paths.agents))
         ? { ok: true, detail: paths.agents }

package/src/lib/skill-catalog.mjs

@@ -15,7 +15,6 @@ export const USER_SKILL_NAMES = Object.freeze([
   "okstra-usage",
   "okstra-schedule-gen",
   "okstra-container-build",
-  "okstra-graphify",
   "okstra-pr-gen",
   "okstra-user-response",
 ]);

package/docs/for-ai/skills/okstra-graphify.md

@@ -1,64 +0,0 @@
-# okstra-graphify AI Manual
-
-## Sources
-
-- Skill source: [`skills/okstra-graphify/SKILL.md`](../../../skills/okstra-graphify/SKILL.md)
-- Graph core (CLI): [`scripts/okstra_ctl/graphify_cmd.py`](../../../scripts/okstra_ctl/graphify_cmd.py)
-- Node wrapper: [`src/commands/graphify.mjs`](../../../src/commands/graphify.mjs)
-
-## Purpose
-
-`okstra-graphify` builds and queries a **knowledge graph** over the project's own okstra memory (the final reports, `decisions/*.md`, `glossary.md`, and briefs under `<projectRoot>/.okstra`). The corpus is **fixed** to `.okstra` and the outputs land at `<projectRoot>/.okstra/graph/` — the CLI enforces both, so this skill takes no user path argument and never touches files outside `.okstra/`.
-
-- Docs-only. There is no code AST extraction here (that is the standalone `/graphify`).
-- Distinguish it from the arbitrary-code / non-okstra folder graph (`/graphify`), single-task inspection (`okstra-inspect`), and rollup (`okstra-rollup`).
-
-## Sub-commands
-
-| Sub-command | What it does |
-|---|---|
-| `build` | Extract entities/relationships from `.okstra` docs (parallel subagent dispatch), then assemble the graph + report + HTML |
-| `query` | BFS/DFS traversal over the graph to answer a broad question |
-| `path` | Shortest path between two named concepts |
-| `explain` | Plain-language explanation of one node and its connections |
-| `wiki` | Agent-crawlable wiki (`index.md` + one article per community) |
-| `mcp` | A stdio MCP server exposing the graph to other agents (opt-in — additionally needs `pip install mcp`) |
-
-## Preflight
-
-A single Bash call starting with the literal token `okstra` (not wrapped in `if`/`eval`/`export`/`$(...)`/`VAR=`/`||`/`&&`/`npx`):
-
-```bash
-okstra preflight --runtime claude-code --json
-```
-
-`ok:true` → carry `projectRoot` as a literal string. Every `okstra graphify` call passes `--project-root <projectRoot>` (**REQUIRED**, no cwd injection — a bare `okstra graphify build` is a usage error). `ok:false` → first check once whether the user pointed at a specific project directory; if it is still `ok:false`, point to `/okstra-setup` and stop. On `unknown command: preflight`, the `okstra` on PATH is older than the skill — point to `npm i -g okstra@latest` and stop.
-
-## build (the core division of labor)
-
-Two parts: **semantic extraction** (subagents read `.okstra` docs and write chunk JSON) → **assemble** (the CLI does clustering and output generation).
-
-1. Detect the corpus: `find <projectRoot>/.okstra -type f -name '*.md' -not -path '*/graph/*'`. If zero, stop.
-2. Semantic extraction: **you MUST use the Agent tool** (reading files one-by-one is forbidden — far slower). Split into chunks of 20-25 files and **dispatch in parallel, once per chunk in a single response**, with `subagent_type="general-purpose"` fixed (`Explore` is read-only, cannot write chunk files, and silently drops results). Each subagent writes `<projectRoot>/.okstra/graph/.chunks/chunk-NN.json`. It MUST fill in EXTRACTED/INFERRED/AMBIGUOUS + `confidence_score`.
-3. Assemble: `okstra graphify build --project-root <projectRoot>` — merges `graph/.chunks/*.json` and writes `graph.json`, `GRAPH_REPORT.md`, `graph.html`. On a `no extraction chunks` error, the subagents did not write their files — re-dispatch.
-
-After a successful build, paste **only** the God Nodes / Surprising Connections / Suggested Questions sections of `GRAPH_REPORT.md` (not the whole file), then offer to trace the single most interesting question via `query`.
-
-## query / path / explain / wiki / mcp
-
-```bash
-okstra graphify query "<question>" --project-root <projectRoot>
-okstra graphify path "<ConceptA>" "<ConceptB>" --project-root <projectRoot>
-okstra graphify explain "<NodeName>" --project-root <projectRoot>
-okstra graphify wiki --project-root <projectRoot>
-okstra graphify mcp --project-root <projectRoot>
-```
-
-`query`/`path`/`explain`/`wiki`/`mcp` **require a built graph** — if the CLI says none exists, run `build` first. `mcp` additionally needs `pip install mcp` and is long-running (the user stops it with Ctrl+C). After doc changes, re-run `build` to re-extract.
-
-## Output Rules
-
-- Be concise, in Korean, unless the user requests otherwise.
-- Outputs go under `<projectRoot>/.okstra/graph/`, in project-relative paths where possible.
-- **Never invent an edge** — if unsure, it is AMBIGUOUS. Never hide cohesion/confidence scores.
-- Say plainly when a fact is not in the graph. Quote `source_file`/`source_location`.

package/runtime/python/okstra_ctl/graphify_cmd.py

@@ -1,225 +0,0 @@
-"""okstra-graphify 스코프 래퍼 — resolve_scope + assemble + main 디스패치.
-
-입력은 항상 ``<project_root>/.okstra`` 로, 출력은 ``<project_root>/.okstra/graph``
-로 고정한다. resolve_scope 가 corpus·output 경로의 유일 정의점이며,
-assemble 이 추출 청크를 그래프·리포트로 병합하고, main 이 query/path/explain/
-mcp/wiki 서브커맨드를 디스패치한다.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-
-import okstra_vendor  # noqa: F401  (registers vendored graphify/networkx)
-
-OUT_DIRNAME = "graph"
-
-
-@dataclass(frozen=True)
-class ScopePaths:
-    corpus: Path
-    out_dir: Path
-
-
-def resolve_scope(project_root: Path) -> ScopePaths:
-    root = Path(project_root).resolve()
-    okstra = root / ".okstra"
-    return ScopePaths(corpus=okstra, out_dir=okstra / OUT_DIRNAME)
-
-
-def assemble(project_root: Path) -> Path:
-    sp = resolve_scope(project_root)
-    chunk_dir = sp.out_dir / ".chunks"
-    chunks = sorted(chunk_dir.glob("*.json")) if chunk_dir.is_dir() else []
-    if not chunks:
-        raise FileNotFoundError(f"no extraction chunks under {chunk_dir}")
-
-    merged = {"nodes": [], "edges": []}
-    for c in chunks:
-        data = json.loads(c.read_text(encoding="utf-8"))
-        merged["nodes"].extend(data.get("nodes", []))
-        merged["edges"].extend(data.get("edges", []))
-
-    from graphify.build import build_from_json
-    from graphify.cluster import cluster, score_all
-    from graphify.analyze import god_nodes, surprising_connections, suggest_questions
-    from graphify.report import generate
-    from graphify.export import to_json, to_html
-
-    sp.out_dir.mkdir(parents=True, exist_ok=True)
-    G = build_from_json(merged)
-    communities = cluster(G)
-    cohesion = score_all(G, communities)
-    gods = god_nodes(G)
-    surprises = surprising_connections(G, communities)
-    labels = {cid: f"Community {cid}" for cid in communities}
-    questions = suggest_questions(G, communities, labels)
-    tokens = {"input": 0, "output": 0}
-    report = generate(
-        G, communities, cohesion, labels, gods, surprises,
-        {"warning": "okstra-graphify: .okstra scope"},
-        tokens, str(sp.corpus), suggested_questions=questions,
-    )
-    (sp.out_dir / "GRAPH_REPORT.md").write_text(report, encoding="utf-8")
-    to_json(G, communities, str(sp.out_dir / "graph.json"))
-    to_html(G, communities, str(sp.out_dir / "graph.html"), community_labels=labels or None)
-    return sp.out_dir
-
-
-def _graph_path(project_root: Path) -> Path:
-    return resolve_scope(project_root).out_dir / "graph.json"
-
-
-def _require_graph(project_root: Path) -> Path:
-    gp = _graph_path(project_root)
-    if not gp.exists():
-        raise SystemExit(
-            f"okstra-graphify: no graph at {gp}. Run `okstra graphify build` first."
-        )
-    return gp
-
-
-def _load_graph(graph_path: Path):
-    from networkx.readwrite import json_graph
-    raw = json.loads(Path(graph_path).read_text(encoding="utf-8"))
-    try:
-        return json_graph.node_link_graph(raw, edges="links")
-    except TypeError:
-        return json_graph.node_link_graph(raw)
-
-
-def _run_query(graph_path: Path, question: str, *, budget: int = 2000, use_dfs: bool = False) -> None:
-    # 벤더 __main__.py query 핸들러(1092–1149) 미러: 그래프 경로만 스코프로 교체.
-    from graphify.serve import _score_nodes, _bfs, _dfs, _subgraph_to_text
-    G = _load_graph(graph_path)
-    terms = [t.lower() for t in question.split() if len(t) > 2]
-    scored = _score_nodes(G, terms)
-    if not scored:
-        print("No matching nodes found.")
-        return
-    start = [nid for _, nid in scored[:5]]
-    nodes, edges = (_dfs if use_dfs else _bfs)(G, start, depth=2)
-    print(_subgraph_to_text(G, nodes, edges, token_budget=budget))
-
-
-def _run_path(graph_path: Path, source_label: str, target_label: str) -> None:
-    # 벤더 __main__.py path 핸들러(1169–1217) 미러.
-    from graphify.serve import _score_nodes
-    import networkx as nx
-    G = _load_graph(graph_path)
-    src_scored = _score_nodes(G, [t.lower() for t in source_label.split()])
-    tgt_scored = _score_nodes(G, [t.lower() for t in target_label.split()])
-    if not src_scored:
-        print(f"No node matching '{source_label}' found.")
-        return
-    if not tgt_scored:
-        print(f"No node matching '{target_label}' found.")
-        return
-    src_nid, tgt_nid = src_scored[0][1], tgt_scored[0][1]
-    try:
-        path_nodes = nx.shortest_path(G, src_nid, tgt_nid)
-    except (nx.NetworkXNoPath, nx.NodeNotFound):
-        print(f"No path found between '{source_label}' and '{target_label}'.")
-        return
-    hops = len(path_nodes) - 1
-    segments = []
-    for i in range(len(path_nodes) - 1):
-        u, v = path_nodes[i], path_nodes[i + 1]
-        edata = G.edges[u, v]
-        rel = edata.get("relation", "")
-        conf = edata.get("confidence", "")
-        conf_str = f" [{conf}]" if conf else ""
-        if i == 0:
-            segments.append(G.nodes[u].get("label", u))
-        segments.append(f"--{rel}{conf_str}--> {G.nodes[v].get('label', v)}")
-    print(f"Shortest path ({hops} hops):\n  " + " ".join(segments))
-
-
-def _run_explain(graph_path: Path, label: str) -> None:
-    # 벤더 __main__.py explain 핸들러(1219–1261) 미러.
-    from graphify.serve import _find_node
-    G = _load_graph(graph_path)
-    matches = _find_node(G, label)
-    if not matches:
-        print(f"No node matching '{label}' found.")
-        return
-    nid = matches[0]
-    d = G.nodes[nid]
-    print(f"Node: {d.get('label', nid)}")
-    print(f"  ID:        {nid}")
-    print(f"  Source:    {d.get('source_file', '')} {d.get('source_location', '')}".rstrip())
-    print(f"  Type:      {d.get('file_type', '')}")
-    print(f"  Community: {d.get('community', '')}")
-    print(f"  Degree:    {G.degree(nid)}")
-    neighbors = list(G.neighbors(nid))
-    if neighbors:
-        print(f"\nConnections ({len(neighbors)}):")
-        for nb in sorted(neighbors, key=lambda n: G.degree(n), reverse=True)[:20]:
-            edata = G.edges[nid, nb]
-            rel = edata.get("relation", "")
-            conf = edata.get("confidence", "")
-            print(f"  --> {G.nodes[nb].get('label', nb)} [{rel}] [{conf}]")
-        if len(neighbors) > 20:
-            print(f"  ... and {len(neighbors) - 20} more")
-
-
-def _run_wiki(project_root: Path) -> int:
-    # 벤더 wiki.to_wiki(wiki.py:168) 미러 — 그래프에서 커뮤니티/라벨/god-node 를
-    # 재구성해 <out_dir>/wiki/ 로 기록한다. assemble 과 동일한 재클러스터 경로.
-    from graphify.build import build_from_json
-    from graphify.cluster import cluster, score_all
-    from graphify.analyze import god_nodes
-    from graphify.wiki import to_wiki
-    sp = resolve_scope(project_root)
-    raw = json.loads((sp.out_dir / "graph.json").read_text(encoding="utf-8"))
-    G = build_from_json(raw)
-    communities = cluster(G)
-    cohesion = score_all(G, communities)
-    gods = god_nodes(G)
-    labels = {cid: f"Community {cid}" for cid in communities}
-    return to_wiki(
-        G, communities, str(sp.out_dir / "wiki"),
-        community_labels=labels or None, cohesion=cohesion, god_nodes_data=gods,
-    )
-
-
-def main(argv: list[str]) -> int:
-    parser = argparse.ArgumentParser(prog="okstra graphify")
-    parser.add_argument(
-        "subcmd",
-        choices=["build", "query", "path", "explain", "mcp", "wiki"],
-    )
-    parser.add_argument("rest", nargs="*")
-    parser.add_argument("--project-root", required=True, type=Path)
-    ns = parser.parse_args(argv)
-    root = ns.project_root
-
-    if ns.subcmd == "build":
-        assemble(root)
-        return 0
-    if ns.subcmd == "mcp":
-        from graphify.serve import serve
-        serve(str(_require_graph(root)))
-        return 0
-    if ns.subcmd == "wiki":
-        _require_graph(root)
-        _run_wiki(root)
-        return 0
-
-    gp = _require_graph(root)
-    if ns.subcmd == "query":
-        _run_query(gp, " ".join(ns.rest))
-    elif ns.subcmd == "path":
-        if len(ns.rest) < 2:
-            raise SystemExit("usage: okstra graphify path <ConceptA> <ConceptB> --project-root <dir>")
-        _run_path(gp, ns.rest[0], ns.rest[1])
-    elif ns.subcmd == "explain":
-        _run_explain(gp, " ".join(ns.rest))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_vendor/graphify/.vendored-version

@@ -1 +0,0 @@
-0.4.23

package/runtime/python/okstra_vendor/graphify/__init__.py

@@ -1,28 +0,0 @@
-"""graphify - extract · build · cluster · analyze · report."""
-
-
-def __getattr__(name):
-    # Lazy imports so `graphify install` works before heavy deps are in place.
-    _map = {
-        "extract": ("graphify.extract", "extract"),
-        "collect_files": ("graphify.extract", "collect_files"),
-        "build_from_json": ("graphify.build", "build_from_json"),
-        "cluster": ("graphify.cluster", "cluster"),
-        "score_all": ("graphify.cluster", "score_all"),
-        "cohesion_score": ("graphify.cluster", "cohesion_score"),
-        "god_nodes": ("graphify.analyze", "god_nodes"),
-        "surprising_connections": ("graphify.analyze", "surprising_connections"),
-        "suggest_questions": ("graphify.analyze", "suggest_questions"),
-        "generate": ("graphify.report", "generate"),
-        "to_json": ("graphify.export", "to_json"),
-        "to_html": ("graphify.export", "to_html"),
-        "to_svg": ("graphify.export", "to_svg"),
-        "to_canvas": ("graphify.export", "to_canvas"),
-        "to_wiki": ("graphify.wiki", "to_wiki"),
-    }
-    if name in _map:
-        import importlib
-        mod_name, attr = _map[name]
-        mod = importlib.import_module(mod_name)
-        return getattr(mod, attr)
-    raise AttributeError(f"module 'graphify' has no attribute {name!r}")