okstra 0.130.4 → 0.131.1

package/runtime/python/okstra_vendor/networkx/utils/random_sequence.py

@@ -1,198 +0,0 @@
-"""
-Utilities for generating random numbers, random sequences, and
-random selections.
-"""
-
-import networkx as nx
-from networkx.utils import py_random_state
-
-__all__ = [
-    "powerlaw_sequence",
-    "is_valid_tree_degree_sequence",
-    "zipf_rv",
-    "cumulative_distribution",
-    "discrete_sequence",
-    "random_weighted_sample",
-    "weighted_choice",
-]
-
-
-# The same helpers for choosing random sequences from distributions
-# uses Python's random module
-# https://docs.python.org/3/library/random.html
-
-
-@py_random_state(2)
-def powerlaw_sequence(n, exponent=2.0, seed=None):
-    """
-    Return sample sequence of length n from a power law distribution.
-    """
-    return [seed.paretovariate(exponent - 1) for i in range(n)]
-
-
-def is_valid_tree_degree_sequence(degree_sequence):
-    """Check if a degree sequence is valid for a tree.
-
-    Two conditions must be met for a degree sequence to be valid for a tree:
-
-    1. The number of nodes must be one more than the number of edges.
-    2. The degree sequence must be trivial or have only strictly positive
-       node degrees.
-
-    Parameters
-    ----------
-    degree_sequence : iterable
-        Iterable of node degrees.
-
-    Returns
-    -------
-    bool
-        Whether the degree sequence is valid for a tree.
-    str
-        Reason for invalidity, or dummy string if valid.
-    """
-    seq = list(degree_sequence)
-    number_of_nodes = len(seq)
-    twice_number_of_edges = sum(seq)
-
-    if 2 * number_of_nodes - twice_number_of_edges != 2:
-        return False, "tree must have one more node than number of edges"
-    elif seq != [0] and any(d <= 0 for d in seq):
-        return False, "nontrivial tree must have strictly positive node degrees"
-    return True, ""
-
-
-@py_random_state(2)
-def zipf_rv(alpha, xmin=1, seed=None):
-    r"""Returns a random value chosen from the Zipf distribution.
-
-    The return value is an integer drawn from the probability distribution
-
-    .. math::
-
-        p(x)=\frac{x^{-\alpha}}{\zeta(\alpha, x_{\min})},
-
-    where $\zeta(\alpha, x_{\min})$ is the Hurwitz zeta function.
-
-    Parameters
-    ----------
-    alpha : float
-      Exponent value of the distribution
-    xmin : int
-      Minimum value
-    seed : integer, random_state, or None (default)
-        Indicator of random number generation state.
-        See :ref:`Randomness<randomness>`.
-
-    Returns
-    -------
-    x : int
-      Random value from Zipf distribution
-
-    Raises
-    ------
-    ValueError:
-      If xmin < 1 or
-      If alpha <= 1
-
-    Notes
-    -----
-    The rejection algorithm generates random values for a the power-law
-    distribution in uniformly bounded expected time dependent on
-    parameters.  See [1]_ for details on its operation.
-
-    Examples
-    --------
-    >>> nx.utils.zipf_rv(alpha=2, xmin=3, seed=42)
-    8
-
-    References
-    ----------
-    .. [1] Luc Devroye, Non-Uniform Random Variate Generation,
-       Springer-Verlag, New York, 1986.
-    """
-    if xmin < 1:
-        raise ValueError("xmin < 1")
-    if alpha <= 1:
-        raise ValueError("a <= 1.0")
-    a1 = alpha - 1.0
-    b = 2**a1
-    while True:
-        u = 1.0 - seed.random()  # u in (0,1]
-        v = seed.random()  # v in [0,1)
-        x = int(xmin * u ** -(1.0 / a1))
-        t = (1.0 + (1.0 / x)) ** a1
-        if v * x * (t - 1.0) / (b - 1.0) <= t / b:
-            break
-    return x
-
-
-def cumulative_distribution(distribution):
-    """Returns normalized cumulative distribution from discrete distribution."""
-
-    cdf = [0.0]
-    cumulative = 0.0
-    for element in distribution:
-        cumulative += element
-        cdf.append(cumulative)
-    return [element / cumulative for element in cdf]
-
-
-@py_random_state(3)
-def discrete_sequence(n, distribution=None, cdistribution=None, seed=None):
-    """
-    Return sample sequence of length n from a given discrete distribution
-    or discrete cumulative distribution.
-
-    One of the following must be specified.
-
-    distribution = histogram of values, will be normalized
-
-    cdistribution = normalized discrete cumulative distribution
-
-    """
-    import bisect
-
-    if cdistribution is not None:
-        cdf = cdistribution
-    elif distribution is not None:
-        cdf = cumulative_distribution(distribution)
-    else:
-        raise nx.NetworkXError(
-            "discrete_sequence: distribution or cdistribution missing"
-        )
-
-    # get a uniform random number
-    inputseq = [seed.random() for i in range(n)]
-
-    # choose from CDF
-    seq = [bisect.bisect_left(cdf, s) - 1 for s in inputseq]
-    return seq
-
-
-@py_random_state(2)
-def random_weighted_sample(mapping, k, seed=None):
-    """Returns k items without replacement from a weighted sample.
-
-    The input is a dictionary of items with weights as values.
-    """
-    if k > len(mapping):
-        raise ValueError("sample larger than population")
-    sample = set()
-    while len(sample) < k:
-        sample.add(weighted_choice(mapping, seed))
-    return list(sample)
-
-
-@py_random_state(1)
-def weighted_choice(mapping, seed=None):
-    """Returns a single element from a weighted sample.
-
-    The input is a dictionary of items with weights as values.
-    """
-    # use roulette method
-    rnd = seed.random() * sum(mapping.values())
-    for k, w in mapping.items():
-        rnd -= w
-        if rnd < 0:
-            return k

package/runtime/python/okstra_vendor/networkx/utils/rcm.py

@@ -1,159 +0,0 @@
-"""
-Cuthill-McKee ordering of graph nodes to produce sparse matrices
-"""
-
-from collections import deque
-from operator import itemgetter
-
-import networkx as nx
-
-from ..utils import arbitrary_element
-
-__all__ = ["cuthill_mckee_ordering", "reverse_cuthill_mckee_ordering"]
-
-
-def cuthill_mckee_ordering(G, heuristic=None):
-    """Generate an ordering (permutation) of the graph nodes to make
-    a sparse matrix.
-
-    Uses the Cuthill-McKee heuristic (based on breadth-first search) [1]_.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph
-
-    heuristic : function, optional
-      Function to choose starting node for RCM algorithm.  If None
-      a node from a pseudo-peripheral pair is used.  A user-defined function
-      can be supplied that takes a graph object and returns a single node.
-
-    Returns
-    -------
-    nodes : generator
-       Generator of nodes in Cuthill-McKee ordering.
-
-    Examples
-    --------
-    >>> from networkx.utils import cuthill_mckee_ordering
-    >>> G = nx.path_graph(4)
-    >>> rcm = list(cuthill_mckee_ordering(G))
-    >>> A = nx.adjacency_matrix(G, nodelist=rcm)
-
-    Smallest degree node as heuristic function:
-
-    >>> def smallest_degree(G):
-    ...     return min(G, key=G.degree)
-    >>> rcm = list(cuthill_mckee_ordering(G, heuristic=smallest_degree))
-
-
-    See Also
-    --------
-    reverse_cuthill_mckee_ordering
-
-    Notes
-    -----
-    The optimal solution the bandwidth reduction is NP-complete [2]_.
-
-
-    References
-    ----------
-    .. [1] E. Cuthill and J. McKee.
-       Reducing the bandwidth of sparse symmetric matrices,
-       In Proc. 24th Nat. Conf. ACM, pages 157-172, 1969.
-       http://doi.acm.org/10.1145/800195.805928
-    .. [2]  Steven S. Skiena. 1997. The Algorithm Design Manual.
-       Springer-Verlag New York, Inc., New York, NY, USA.
-    """
-    for c in nx.connected_components(G):
-        yield from connected_cuthill_mckee_ordering(G.subgraph(c), heuristic)
-
-
-def reverse_cuthill_mckee_ordering(G, heuristic=None):
-    """Generate an ordering (permutation) of the graph nodes to make
-    a sparse matrix.
-
-    Uses the reverse Cuthill-McKee heuristic (based on breadth-first search)
-    [1]_.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph
-
-    heuristic : function, optional
-      Function to choose starting node for RCM algorithm.  If None
-      a node from a pseudo-peripheral pair is used.  A user-defined function
-      can be supplied that takes a graph object and returns a single node.
-
-    Returns
-    -------
-    nodes : generator
-       Generator of nodes in reverse Cuthill-McKee ordering.
-
-    Examples
-    --------
-    >>> from networkx.utils import reverse_cuthill_mckee_ordering
-    >>> G = nx.path_graph(4)
-    >>> rcm = list(reverse_cuthill_mckee_ordering(G))
-    >>> A = nx.adjacency_matrix(G, nodelist=rcm)
-
-    Smallest degree node as heuristic function:
-
-    >>> def smallest_degree(G):
-    ...     return min(G, key=G.degree)
-    >>> rcm = list(reverse_cuthill_mckee_ordering(G, heuristic=smallest_degree))
-
-
-    See Also
-    --------
-    cuthill_mckee_ordering
-
-    Notes
-    -----
-    The optimal solution the bandwidth reduction is NP-complete [2]_.
-
-    References
-    ----------
-    .. [1] E. Cuthill and J. McKee.
-       Reducing the bandwidth of sparse symmetric matrices,
-       In Proc. 24th Nat. Conf. ACM, pages 157-72, 1969.
-       http://doi.acm.org/10.1145/800195.805928
-    .. [2]  Steven S. Skiena. 1997. The Algorithm Design Manual.
-       Springer-Verlag New York, Inc., New York, NY, USA.
-    """
-    return reversed(list(cuthill_mckee_ordering(G, heuristic=heuristic)))
-
-
-def connected_cuthill_mckee_ordering(G, heuristic=None):
-    # the cuthill mckee algorithm for connected graphs
-    if heuristic is None:
-        start = pseudo_peripheral_node(G)
-    else:
-        start = heuristic(G)
-    visited = {start}
-    queue = deque([start])
-    while queue:
-        parent = queue.popleft()
-        yield parent
-        nd = sorted(G.degree(set(G[parent]) - visited), key=itemgetter(1))
-        children = [n for n, d in nd]
-        visited.update(children)
-        queue.extend(children)
-
-
-def pseudo_peripheral_node(G):
-    # helper for cuthill-mckee to find a node in a "pseudo peripheral pair"
-    # to use as good starting node
-    u = arbitrary_element(G)
-    lp = 0
-    v = u
-    while True:
-        spl = nx.shortest_path_length(G, v)
-        l = max(spl.values())
-        if l <= lp:
-            break
-        lp = l
-        farthest = (n for n, dist in spl.items() if dist == l)
-        v, deg = min(G.degree(farthest), key=itemgetter(1))
-    return v

package/runtime/python/okstra_vendor/networkx/utils/union_find.py

@@ -1,106 +0,0 @@
-"""
-Union-find data structure.
-"""
-
-from networkx.utils import groups
-
-
-class UnionFind:
-    """Union-find data structure.
-
-    Each unionFind instance X maintains a family of disjoint sets of
-    hashable objects, supporting the following two methods:
-
-    - X[item] returns a name for the set containing the given item.
-      Each set is named by an arbitrarily-chosen one of its members; as
-      long as the set remains unchanged it will keep the same name. If
-      the item is not yet part of a set in X, a new singleton set is
-      created for it.
-
-    - X.union(item1, item2, ...) merges the sets containing each item
-      into a single larger set.  If any item is not yet part of a set
-      in X, it is added to X as one of the members of the merged set.
-
-      Union-find data structure. Based on Josiah Carlson's code,
-      https://code.activestate.com/recipes/215912/
-      with significant additional changes by D. Eppstein.
-      http://www.ics.uci.edu/~eppstein/PADS/UnionFind.py
-
-    """
-
-    def __init__(self, elements=None):
-        """Create a new empty union-find structure.
-
-        If *elements* is an iterable, this structure will be initialized
-        with the discrete partition on the given set of elements.
-
-        """
-        if elements is None:
-            elements = ()
-        self.parents = {}
-        self.weights = {}
-        for x in elements:
-            self.weights[x] = 1
-            self.parents[x] = x
-
-    def __getitem__(self, object):
-        """Find and return the name of the set containing the object."""
-
-        # check for previously unknown object
-        if object not in self.parents:
-            self.parents[object] = object
-            self.weights[object] = 1
-            return object
-
-        # find path of objects leading to the root
-        path = []
-        root = self.parents[object]
-        while root != object:
-            path.append(object)
-            object = root
-            root = self.parents[object]
-
-        # compress the path and return
-        for ancestor in path:
-            self.parents[ancestor] = root
-        return root
-
-    def __iter__(self):
-        """Iterate through all items ever found or unioned by this structure."""
-        return iter(self.parents)
-
-    def to_sets(self):
-        """Iterates over the sets stored in this structure.
-
-        For example::
-
-            >>> partition = UnionFind("xyz")
-            >>> sorted(map(sorted, partition.to_sets()))
-            [['x'], ['y'], ['z']]
-            >>> partition.union("x", "y")
-            >>> sorted(map(sorted, partition.to_sets()))
-            [['x', 'y'], ['z']]
-
-        """
-        # Ensure fully pruned paths
-        for x in self.parents:
-            _ = self[x]  # Evaluated for side-effect only
-
-        yield from groups(self.parents).values()
-
-    def union(self, *objects):
-        """Find the sets containing the objects and merge them all."""
-        # Find the heaviest root according to its weight.
-        roots = iter(
-            sorted(
-                {self[x] for x in objects}, key=lambda r: self.weights[r], reverse=True
-            )
-        )
-        try:
-            root = next(roots)
-        except StopIteration:
-            return
-
-        for r in roots:
-            self.weights[root] += self.weights[r]
-            self.parents[r] = root

package/runtime/skills/okstra-graphify/SKILL.md

@@ -1,169 +0,0 @@
----
-name: okstra-graphify
-description: >-
-  Use when the user wants to build, query, or navigate a knowledge graph over an okstra project's own `.okstra/` memory — its reports, decision records, and glossary. Turns that docs corpus into a persistent graph with community detection and an honest EXTRACTED/INFERRED/AMBIGUOUS audit trail, then answers cross-document questions the flat files can't. Trigger phrases include "okstra graphify", "graph the .okstra docs", "build okstra knowledge graph", "query okstra graph", "what connects to X in the okstra docs", "build the okstra graph", "graph the decision records". NOT for graphing arbitrary code or non-okstra folders (that is the standalone /graphify), and NOT for single-task inspection (okstra-inspect) or rollups (okstra-rollup).
-trigger: /okstra-graphify
----
-
-# OKSTRA Graphify
-
-Build and query a knowledge graph over the project's own okstra memory. The corpus is **fixed** to `<projectRoot>/.okstra` and the outputs land at `<projectRoot>/.okstra/graph/` — the `okstra graphify` CLI enforces both, so this skill never takes a user path argument and never touches files outside `.okstra/`.
-
-Only `.okstra/**/*.md` (final reports, `decisions/*.md`, `glossary.md`, briefs) are indexed. This is docs-only — there is no code AST extraction here (that lives in the standalone `/graphify`).
-
-| Sub-command | What it does |
-|---|---|
-| `build` | Extract entities/relationships from `.okstra` docs (subagent dispatch), then assemble the graph + report + HTML. |
-| `query` | BFS/DFS traversal to answer a broad question over the graph. |
-| `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` | Start a stdio MCP server exposing the graph to other agents (opt-in — additionally needs `pip install mcp`). |
-
-## Step 0: Preflight (shared)
-
-Before any sub-command:
-
-<!-- BEGIN FRAGMENT: bash-invocation-rule -->
-Run one Bash tool call, starting with the literal token `okstra` (never wrapped in `if`/`eval`/`export`/`$(...)`/`VAR=...`/`||`/`&&`/`npx` — a non-literal leading token defeats the `Bash(okstra:*)` permission match):
-<!-- END FRAGMENT: bash-invocation-rule -->
-
-```bash
-okstra preflight --runtime claude-code --json
-```
-
-Parse the stdout JSON:
-- `ok: true` → carry `projectRoot` as a literal string; it is the `--project-root` value for every sub-command below.
-- `ok: false` → before concluding "no setup", ask whether the user pointed at a specific project directory. If so, re-run `okstra preflight --runtime claude-code --cwd <that-dir> --json`. Only if this **also** returns `ok:false` do you tell the user: "this project has no okstra setup. Run `/okstra-setup` first." Then stop.
-
-<!-- BEGIN FRAGMENT: preflight-outdated-cli -->
-If the call fails with `unknown command: preflight`, the `okstra` binary on PATH predates this skill — tell the user to update it (`npm i -g okstra@latest`), then stop (`/okstra-setup` does not update the binary).
-<!-- END FRAGMENT: preflight-outdated-cli -->
-
-Every `okstra graphify` call below passes `--project-root <projectRoot>` — `--project-root` is REQUIRED and there is no cwd injection; a bare `okstra graphify build` fails with a usage error.
-
-## Step 1: Dispatch by intent
-
-Classify the request into one sub-command using the table above. If ambiguous ("show me the okstra graph"), ask which — enumerate the full sub-command table as a numbered text list and let the user pick. `build` is the prerequisite for `query`/`path`/`explain`/`wiki`/`mcp`; if the user asks to query before a graph exists, the CLI will fail cleanly with `no graph … Run \`okstra graphify build\` first` — run `build` first.
-
----
-
-## build
-
-Two parts: **semantic extraction** (subagents read `.okstra` docs and write chunk JSON), then **assemble** (the CLI clusters and generates outputs).
-
-### build.1 — Detect the corpus
-
-The corpus is fixed to `<projectRoot>/.okstra`. Glob the doc files yourself:
-
-```bash
-find <projectRoot>/.okstra -type f -name '*.md' -not -path '*/graph/*'
-```
-
-Present a clean summary — `Corpus: N markdown files under <projectRoot>/.okstra` (reports, decisions, glossary, briefs). If zero files, stop with "No `.okstra` docs found — run some okstra tasks first, then graph them." The CLI disables graphify's filename-based sensitive-file skip inside `.okstra` (it is okstra's own generated memory, not a secrets store), so do not drop files whose names contain `token`/`secret`.
-
-### build.2 — Semantic extraction (parallel subagents)
-
-**MANDATORY: use the Agent tool.** Reading files one-by-one yourself is forbidden — it is far slower.
-
-1. Split the doc list into chunks of 20-25 files. Group files from the same directory (e.g. all `decisions/`) together so cross-file relationships surface. Print a one-line estimate: `Semantic extraction: ~N files → X agents`.
-2. Call the Agent tool **once per chunk, all in a single response** so they run in parallel. **`subagent_type="general-purpose"`** always — never `Explore` (it is read-only and cannot write chunk files, silently dropping results).
-3. Each subagent writes its fragment to `<projectRoot>/.okstra/graph/.chunks/chunk-NN.json`.
-
-Each subagent receives this exact prompt (substitute FILE_LIST, CHUNK_NUM, TOTAL_CHUNKS, OUT_PATH = `<projectRoot>/.okstra/graph/.chunks/chunk-<NN>.json`):
-
-```
-You are an okstra-graphify extraction subagent over an okstra project's `.okstra` docs
-(final reports, decision records, glossary, briefs). Read the files listed and extract a
-knowledge-graph fragment. Write ONLY valid JSON (schema below) to OUT_PATH — mkdir -p its
-parent first. No explanation, no markdown fences.
-
-Files (chunk CHUNK_NUM of TOTAL_CHUNKS):
-FILE_LIST
-
-Rules:
-- EXTRACTED: relationship explicit in source (a report cites a decision, "see DEC-0003", a task references another task-key).
-- INFERRED: reasonable inference (two reports discuss the same subsystem; a glossary term used in a decision).
-- AMBIGUOUS: uncertain — flag, do not omit.
-Extract named concepts, task-keys, decision ids, glossary terms, subsystems, and rationale
-(sections explaining WHY a decision was made) as nodes; link them with the relations below.
-Add a `semantically_similar_to` INFERRED edge (confidence_score 0.6-0.95) when two concepts in
-this chunk address the same problem without any explicit link. Only when genuinely non-obvious.
-
-confidence_score is REQUIRED on every edge:
-- EXTRACTED → 1.0 always
-- INFERRED → 0.6-0.9 (0.8-0.9 with clear evidence, 0.6-0.7 with some uncertainty)
-- AMBIGUOUS → 0.1-0.3
-
-Node ID: lowercase `[a-z0-9_]` only. Format `{stem}_{entity}` — filename stem + symbol,
-both normalized (non-alphanumeric → `_`).
-
-Output exactly this JSON to OUT_PATH:
-{"nodes":[{"id":"dec_0003_stage_isolation","label":"Human Readable Name","file_type":"document","source_file":"relative/path","source_location":null}],"edges":[{"source":"node_id","target":"node_id","relation":"references|cites|conceptually_related_to|shares_data_with|semantically_similar_to|rationale_for","confidence":"EXTRACTED|INFERRED|AMBIGUOUS","confidence_score":1.0,"source_file":"relative/path","weight":1.0}]}
-```
-
-After all subagents finish, confirm each `chunk-NN.json` exists on disk (the success signal). If a file is missing, warn — the subagent may have been read-only — and re-dispatch with `general-purpose`. If more than half the chunks are missing, stop and tell the user to re-run.
-
-### build.3 — Assemble
-
-```bash
-okstra graphify build --project-root <projectRoot>
-```
-
-This merges every `graph/.chunks/*.json` (`nodes` + `edges`), builds the graph, runs community detection, and writes to `<projectRoot>/.okstra/graph/`:
-- `graph.json` — raw graph data
-- `GRAPH_REPORT.md` — audit report (god nodes, surprising connections, suggested questions, token/confidence audit)
-- `graph.html` — interactive graph, open in any browser
-
-If the CLI errors with `no extraction chunks`, the subagents in build.2 did not write their files — re-dispatch them. After a successful build, paste the God Nodes / Surprising Connections / Suggested Questions sections from `GRAPH_REPORT.md` (not the whole file), then offer to trace the single most interesting suggested question via `query`.
-
----
-
-## query
-
-```bash
-okstra graphify query "<question>" --project-root <projectRoot>
-```
-
-BFS traversal over the graph; prints the relevant subgraph (nodes, edge relations, confidence tags, source locations). Answer using **only** what the subgraph contains — quote `source_file`/`source_location` when citing a fact, and say so plainly if the graph lacks the information rather than inventing edges.
-
-## path
-
-```bash
-okstra graphify path "<ConceptA>" "<ConceptB>" --project-root <projectRoot>
-```
-
-Prints the shortest path between two named concepts (each hop's relation + confidence). Explain in plain language what each hop means and why the bridge is significant.
-
-## explain
-
-```bash
-okstra graphify explain "<NodeName>" --project-root <projectRoot>
-```
-
-Prints one node's source, type, community, degree, and its connections. Write a 3-5 sentence explanation of what it is, what it connects to, and why — cite source locations.
-
-## wiki
-
-```bash
-okstra graphify wiki --project-root <projectRoot>
-```
-
-Writes an agent-crawlable wiki to `<projectRoot>/.okstra/graph/wiki/` — `index.md` (entry point) plus one article per community. Point the user at `index.md`.
-
-## mcp
-
-```bash
-okstra graphify mcp --project-root <projectRoot>
-```
-
-Starts a stdio MCP server exposing the graph (`query_graph`, `get_node`, `get_neighbors`, `shortest_path`, …) so other agents can query it live. Long-running — the user Ctrl+C's to stop. This sub-command additionally requires `pip install mcp` (opt-in MCP server); the core `build`/`query`/`path`/`explain`/`wiki` sub-commands need no extra install. After doc changes, re-run `build` for LLM semantic re-extraction.
-
----
-
-## Output Rules (shared)
-
-- Respond concisely in Korean unless the user requests otherwise.
-- Use project-relative paths where possible; outputs live under `<projectRoot>/.okstra/graph/`.
-- Never invent an edge — if unsure, it is AMBIGUOUS. Never hide cohesion/confidence scores.
-- `query`/`path`/`explain`/`wiki`/`mcp` require a built graph; if the CLI says none exists, run `build` first.

package/src/commands/graphify.mjs

@@ -1,32 +0,0 @@
-import { runPythonModule } from "../lib/python-helper.mjs";
-
-const USAGE = `okstra graphify — build/query a .okstra-scoped knowledge graph
-
-Usage:
-  okstra graphify build   --project-root <dir> [options]
-  okstra graphify query   --project-root <dir> [options]
-  okstra graphify path    --project-root <dir> [options]
-  okstra graphify explain --project-root <dir> [options]
-  okstra graphify mcp     --project-root <dir> [options]
-  okstra graphify watch   --project-root <dir> [options]
-  okstra graphify wiki    --project-root <dir> [options]
-
---project-root <dir> targets the project whose .okstra/ subtree holds the graph.
-All arguments are forwarded to the python wrapper (okstra_ctl.graphify_cmd);
---project-root is required by the wrapper, so a bare 'okstra graphify build'
-fails cleanly with an argparse usage error.
-`;
-
-export async function run(args) {
-  if (args.includes("--help") || args.includes("-h")) {
-    process.stdout.write(USAGE);
-    return 0;
-  }
-
-  const result = await runPythonModule({
-    module: "okstra_ctl.graphify_cmd",
-    args,
-    stdio: "inherit-stdout",
-  });
-  return result.code;
-}