@herjarsa/omo-meta-governor 0.13.1 → 0.14.0

package/dist/codegraph-tools.d.ts

@@ -0,0 +1,100 @@
+/**
+ * codegraph-tools — high-level wrappers around codegraph's sub-commands
+ * (node, callers, impact, files) for use in custom tools.
+ *
+ * codegraph is invoked via the `codegraph` CLI (not via MCP). Available
+ * sub-commands we wrap here:
+ *   - codegraph node <symbol>      → get source + callers of a symbol
+ *   - codegraph callers <symbol>   → list call sites of a symbol
+ *   - codegraph impact <symbol>    → full impact analysis (callers + tests + docs)
+ *   - codegraph files              → list indexed files
+ *
+ * v0.14.0 adds these on top of the v0.13.0 `omo_search` (which uses
+ * `codegraph explore`). Together they give the LLM a full codegraph
+ * toolkit: search, find, callers, impact, files.
+ *
+ * Design:
+ * - Pure CLI invocation via GraphRetrieval (which already handles
+ *   timeout, error catching, and graceful degradation)
+ * - Each function returns null when the tool is unavailable — the
+ *   caller decides what to do (e.g., suggest a fallback)
+ * - All functions take cwd + optional cli path override
+ */
+import { type GraphRetrieval } from "./graph-retrieval";
+export interface OmoFindResult {
+    /** The symbol that was searched */
+    symbol: string;
+    /** Source code of the definition (formatted) */
+    source: string | null;
+    /** List of call sites (file:line format) */
+    callers: Array<{
+        file: string;
+        line: number;
+        context: string;
+    }>;
+    /** True if the symbol was found */
+    found: boolean;
+    /** Tool that produced the result */
+    kind: "codegraph" | "graphify" | null;
+    /** Total time taken */
+    durationMs: number;
+}
+export interface OmoImpactResult {
+    /** The symbol being analyzed */
+    symbol: string;
+    /** Direct callers (file:line) */
+    directCallers: Array<{
+        file: string;
+        line: number;
+        context: string;
+    }>;
+    /** Transitive callers (if available from the tool) */
+    transitiveCallers: Array<{
+        file: string;
+        line: number;
+        context: string;
+    }>;
+    /** Test files affected (if available) */
+    testFiles: string[];
+    /** Documentation files affected (if available) */
+    docFiles: string[];
+    /** Total affected file count */
+    totalAffectedFiles: number;
+    /** Tool that produced the result */
+    kind: "codegraph" | "graphify" | null;
+    /** Total time taken */
+    durationMs: number;
+    /** Whether the analysis timed out */
+    timedOut: boolean;
+}
+export interface OmoFilesResult {
+    files: string[];
+    count: number;
+    kind: "codegraph" | "graphify" | null;
+    durationMs: number;
+}
+/**
+ * Default entry point: use the singleton GraphRetrieval.
+ * Tests can construct their own CodeGraphTools with a custom instance.
+ */
+export declare class CodeGraphTools {
+    private retrieval;
+    constructor(retrieval?: GraphRetrieval);
+    /**
+     * Find a symbol's definition and direct callers.
+     * Uses `codegraph node <symbol>` for codegraph, `graphify query <symbol>` for graphify.
+     */
+    find(symbol: string, cwd: string, timeoutMs?: number): Promise<OmoFindResult>;
+    /**
+     * Analyze the impact of changing a symbol. Lists direct callers,
+     * transitive callers, and affected test/doc files.
+     * Uses `codegraph impact <symbol>` if available, else `codegraph callers`.
+     */
+    impact(symbol: string, cwd: string, timeoutMs?: number): Promise<OmoImpactResult>;
+    /**
+     * List indexed files. Uses `codegraph files`.
+     */
+    listFiles(cwd: string, timeoutMs?: number): Promise<OmoFilesResult>;
+}
+/** Returns the process-wide CodeGraphTools singleton. */
+export declare function getDefaultCodeGraphTools(): CodeGraphTools;

package/dist/custom-tools.d.ts

@@ -22,6 +22,7 @@ import { type ToolContext, type ToolResult } from "@opencode-ai/plugin";
 import type { SqliteBackend } from "./sqlite-backend";
 import type { GraphRetrieval } from "./graph-retrieval";
 import type { MetricsCollector } from "./metrics";
+import { type CodeGraphTools } from "./codegraph-tools";
 export interface OmoSearchDeps {
     graphRetrieval: GraphRetrieval;
     cwd: string;
@@ -73,3 +74,145 @@ export declare function buildOmoHealthTool(deps: OmoHealthDeps): {
     args: {};
     execute(args: Record<string, never>, context: ToolContext): Promise<ToolResult>;
 };
+export interface OmoFindDeps {
+    codeGraph?: CodeGraphTools;
+    cwd: string;
+}
+/**
+ * Build the `omo_find` tool. Resolves a symbol to its source code location
+ * and lists direct call sites. Uses `codegraph node <symbol>` (with
+ * `graphify query <symbol>` as fallback when codegraph is unavailable).
+ */
+export declare function buildOmoFindTool(deps: OmoFindDeps): {
+    description: string;
+    args: {
+        symbol: import("zod").ZodString;
+    };
+    execute(args: {
+        symbol: string;
+    }, context: ToolContext): Promise<ToolResult>;
+};
+export interface OmoImpactDeps {
+    codeGraph?: CodeGraphTools;
+    cwd: string;
+}
+/**
+ * Build the `omo_impact` tool. Lists all call sites of a symbol plus
+ * affected test and doc files. Uses `codegraph impact <symbol>` (falls
+ * back to `codegraph callers` when impact is unavailable).
+ */
+export declare function buildOmoImpactTool(deps: OmoImpactDeps): {
+    description: string;
+    args: {
+        symbol: import("zod").ZodString;
+    };
+    execute(args: {
+        symbol: string;
+    }, context: ToolContext): Promise<ToolResult>;
+};
+export interface OmoRememberDeps {
+}
+/**
+ * Build the `omo_remember` tool. Persists a fact/observation/lesson to
+ * AgentMemory by instructing the LLM to call `agentmemory_memory_save`.
+ */
+export declare function buildOmoRememberTool(deps: OmoRememberDeps): {
+    description: string;
+    args: {
+        content: import("zod").ZodString;
+        concepts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        type: import("zod").ZodOptional<import("zod").ZodEnum<{
+            pattern: "pattern";
+            fact: "fact";
+            observation: "observation";
+        }>>;
+    };
+    execute(args: {
+        content: string;
+        concepts?: string[] | undefined;
+        type?: "pattern" | "fact" | "observation" | undefined;
+    }, context: ToolContext): Promise<ToolResult>;
+};
+export interface OmoRecallMcpDeps {
+}
+/**
+ * Build the `omo_recall_mcp` tool. Searches AgentMemory by sending a
+ * query to the LLM that triggers `agentmemory_memory_smart_search`.
+ *
+ * Note: prefer `omo_recall` (which queries SQLite FTS5 locally) for fast
+ * local recall. Use `omo_recall_mcp` when you specifically need to search
+ * AgentMemory's persistent cross-session memory.
+ */
+export declare function buildOmoRecallMcpTool(deps: OmoRecallMcpDeps): {
+    description: string;
+    args: {
+        query: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        query: string;
+        limit?: number | undefined;
+    }, context: ToolContext): Promise<ToolResult>;
+};
+export interface OmoRuleDeps {
+}
+/**
+ * Build the `omo_rule` tool. Saves a durable rule to Magic Context that
+ * persists across sessions. Categorized by type (PROJECT_RULES, ARCHITECTURE,
+ * CONSTRAINTS, CONFIG_VALUES, NAMING). Uses `ctx_memory(action="write")`.
+ */
+export declare function buildOmoRuleTool(deps: OmoRuleDeps): {
+    description: string;
+    args: {
+        category: import("zod").ZodEnum<{
+            PROJECT_RULES: "PROJECT_RULES";
+            ARCHITECTURE: "ARCHITECTURE";
+            CONSTRAINTS: "CONSTRAINTS";
+            CONFIG_VALUES: "CONFIG_VALUES";
+            NAMING: "NAMING";
+        }>;
+        content: import("zod").ZodString;
+    };
+    execute(args: {
+        category: "PROJECT_RULES" | "ARCHITECTURE" | "CONSTRAINTS" | "CONFIG_VALUES" | "NAMING";
+        content: string;
+    }, context: ToolContext): Promise<ToolResult>;
+};
+export interface OmoHistoryDeps {
+}
+/**
+ * Build the `omo_history` tool. Searches git commit history and prior
+ * conversations via Magic Context. Uses `ctx_search` with sources=["git_commit", "message"].
+ */
+export declare function buildOmoHistoryTool(deps: OmoHistoryDeps): {
+    description: string;
+    args: {
+        query: import("zod").ZodString;
+        sources: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+            message: "message";
+            git_commit: "git_commit";
+        }>>>;
+    };
+    execute(args: {
+        query: string;
+        sources?: ("message" | "git_commit")[] | undefined;
+    }, context: ToolContext): Promise<ToolResult>;
+};
+export interface OmoNoteDeps {
+}
+/**
+ * Build the `omo_note` tool. Writes a session-scoped working note via
+ * Magic Context. Notes are for the current task only (ephemeral context).
+ * Uses `ctx_note(action="write")`.
+ */
+export declare function buildOmoNoteTool(deps: OmoNoteDeps): {
+    description: string;
+    args: {
+        content: import("zod").ZodString;
+        surfaceCondition: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        content: string;
+        surfaceCondition?: string | undefined;
+    }, context: ToolContext): Promise<ToolResult>;
+};

package/dist/graph-retrieval.d.ts

@@ -88,6 +88,32 @@ export declare class GraphRetrieval {
      */
     invoke(projectDir: string, query: string, options?: InvokeOptions): Promise<GraphInvocationResult>;
     private spawnWithTimeout;
+    /**
+     * Get the source code and direct callers of a symbol.
+     * Runs `codegraph node <symbol> --project-path <cwd>`.
+     */
+    invokeNode(symbol: string, projectDir: string, options?: InvokeOptions): Promise<GraphInvocationResult>;
+    /**
+     * List all call sites of a symbol.
+     * Runs `codegraph callers <symbol> --project-path <cwd>`.
+     */
+    invokeCallers(symbol: string, projectDir: string, options?: InvokeOptions): Promise<GraphInvocationResult>;
+    /**
+     * Full impact analysis: direct callers, transitive callers,
+     * affected test files, affected doc files.
+     * Runs `codegraph impact <symbol> --project-path <cwd>`.
+     */
+    invokeImpact(symbol: string, projectDir: string, options?: InvokeOptions): Promise<GraphInvocationResult>;
+    /**
+     * List all indexed files.
+     * Runs `codegraph files --project-path <cwd>`.
+     */
+    invokeFiles(projectDir: string, options?: InvokeOptions): Promise<GraphInvocationResult>;
+    /**
+     * Run a codegraph sub-command and return the result.
+     * Returns null result if codegraph is not available.
+     */
+    private invokeCodegraphSubcommand;
 }
 /** Returns the process-wide singleton, creating it on first use. */
 export declare function getDefaultGraphRetrieval(): GraphRetrieval;