pudu-ai 0.2.21 → 0.2.22

package/README.md

@@ -148,6 +148,8 @@ Deterministic repository search. Optional Python 3.10+, `rg`, and `ast-grep`. No
 ```bash
 npx pudu-ai repo search validate_user --repo . --json
 npx pudu-ai repo search --structural 'def $FUNC($$$ARGS): $$$BODY'
+npx pudu-ai repo graph --repo .
+npx pudu-ai repo harness --task "fix validate_user" --json
 npx pudu-ai repo search validate_user --lang es
 ```
 

package/dist/cli/{chunk-QGEXKMQ5.js → chunk-6NXOK4OD.js}

@@ -30,16 +30,33 @@ var en = {
   aboutRepoSearch: "Deterministic repository search (Pudu Agent Lab). Literal strings use rg; syntactic patterns use ast-grep. No LLM. Missing tools are reported, never faked.",
   repoSearchTitle: "Pudu Agent Lab \u2014 repo search",
   repoNeedQuery: "Pass a query or --structural PATTERN, e.g. npx pudu-ai repo search validate_user --json",
-  repoUnknownSubcommand: "Unknown repo subcommand: {sub}. Iteration 1 supports search only.",
+  repoUnknownSubcommand: "Unknown repo subcommand: {sub}. Supported: search, graph, harness.",
   repoPythonMissing: "python3 not found. Agent Lab search needs Python 3.10+ on PATH.",
   repoToolMissing: "{tool} not found on PATH",
   repoNoMatches: "No matches.",
-  repoHelp: `Pudu Agent Lab \u2014 repository search
+  repoNeedTask: 'Pass a task, e.g. npx pudu-ai repo harness --task "fix validate_user" --repo .',
+  repoGraphTitle: "AGENT LAB \u2014 IMPLEMENTATION GRAPH",
+  aboutRepoGraph: "Python stdlib AST graph (imports, defs, calls, inherits). Optional Graphify file if present. Edges are EXTRACTED or RESOLVED. Never invented.",
+  repoGraphBuilding: "Building graph of this folder\u2026",
+  repoGraphEmpty: "No Python files with extractable structure.",
+  repoGraphFiles: "Files",
+  repoGraphNodes: "Nodes",
+  repoGraphEdges: "Edges",
+  repoTokens: "Token estimate",
+  repoEffortTitle: "TASK EFFORT (DERIVED)",
+  repoHarnessPrompt: "HARNESS TASK",
+  repoHarnessPromptHint: "Type the coding task, then Enter",
+  repoHarnessEnter: "Enter = pick local model from effort   Esc = back",
+  repoHarnessNoPrompt: "(empty prompt \u2014 effort is still from the graph)",
+  repoHarnessModel: "BEST LOCAL MODEL FOR THIS TASK",
+  repoHelp: `Pudu Agent Lab \u2014 repository search, graph, harness
 
 Usage:
   npx pudu-ai repo search QUERY
   npx pudu-ai repo search QUERY --repo PATH --json
   npx pudu-ai repo search --structural 'def $FUNC($$$ARGS): $$$BODY'
+  npx pudu-ai repo graph --repo PATH
+  npx pudu-ai repo harness --task "fix auth" --repo PATH --json
 
 Flags:
   --repo PATH         Repository root (default: cwd)
@@ -47,7 +64,8 @@ Flags:
   --intent INTENT     TEXT | STRUCTURAL | RELATIONSHIP | IMPACT | SEMANTIC | UNKNOWN
   --glob GLOB         Repeatable include glob
   --limit N           Max matches (default 100)
-  --json              Machine-readable SearchResult
+  --task TEXT         Harness task prompt
+  --json              Machine-readable JSON
 `,
   nav: "[S] Setup/Install  [B] Benchmark  [M] Models  [R] Recommend  [T] Tasks  [H] Hardware  [C] Compare  [L] History  [Q] Quit",
   setupTitle: "SETUP \u2014 INSTALL MODELS & AGENTS",
@@ -197,6 +215,8 @@ Usage:
   npx pudu-ai launch opencode --yes
   npx pudu-ai repo search QUERY
   npx pudu-ai repo search --structural 'def $FUNC($$$ARGS): $$$BODY'
+  npx pudu-ai repo graph
+  npx pudu-ai repo harness --task "fix auth"
 
 Flags:
   --json          Machine-readable JSON (no TUI)
@@ -215,6 +235,7 @@ Flags:
   --intent        TEXT | STRUCTURAL | RELATIONSHIP | IMPACT | SEMANTIC | UNKNOWN
   --glob          Repeatable include glob for repo search
   --limit         Max repo search matches
+  --task          Harness task prompt
 
 Credits:
   Measured values come from llama-bench and OS telemetry.
@@ -256,24 +277,42 @@ var es = {
   aboutRepoSearch: "B\xFAsqueda determinista de repositorio (Pudu Agent Lab). Cadenas literales: rg; patrones sint\xE1cticos: ast-grep. Sin LLM. Si falta una herramienta se informa, no se inventa.",
   repoSearchTitle: "Pudu Agent Lab \u2014 b\xFAsqueda de repo",
   repoNeedQuery: "Pasa una consulta o --structural PATR\xD3N, p. ej. npx pudu-ai repo search validate_user --json",
-  repoUnknownSubcommand: "Subcomando de repo desconocido: {sub}. La iteraci\xF3n 1 solo admite search.",
+  repoUnknownSubcommand: "Subcomando de repo desconocido: {sub}. Soportados: search, graph, harness.",
   repoPythonMissing: "No se encontr\xF3 python3. La b\xFAsqueda de Agent Lab necesita Python 3.10+ en PATH.",
   repoToolMissing: "{tool} no est\xE1 en PATH",
   repoNoMatches: "Sin coincidencias.",
-  repoHelp: `Pudu Agent Lab \u2014 b\xFAsqueda de repositorio
+  repoNeedTask: 'Pasa una tarea, p. ej. npx pudu-ai repo harness --task "arreglar validate_user" --repo .',
+  repoGraphTitle: "AGENT LAB \u2014 GRAFO DE IMPLEMENTACI\xD3N",
+  aboutRepoGraph: "Grafo AST de Python (imports, defs, llamadas, herencias). Graphify opcional si existe el archivo. Aristas EXTRACTED o RESOLVED. Nunca inventadas.",
+  repoGraphBuilding: "Construyendo el grafo de esta carpeta\u2026",
+  repoGraphEmpty: "No hay Python con estructura extra\xEDble.",
+  repoGraphFiles: "Archivos",
+  repoGraphNodes: "Nodos",
+  repoGraphEdges: "Aristas",
+  repoTokens: "Estimaci\xF3n de tokens",
+  repoEffortTitle: "ESFUERZO DE TAREA (DERIVED)",
+  repoHarnessPrompt: "TAREA HARNESS",
+  repoHarnessPromptHint: "Escribe la tarea de c\xF3digo y pulsa Enter",
+  repoHarnessEnter: "Enter = elegir modelo local seg\xFAn esfuerzo   Esc = atr\xE1s",
+  repoHarnessNoPrompt: "(prompt vac\xEDo \u2014 el esfuerzo sigue saliendo del grafo)",
+  repoHarnessModel: "MEJOR MODELO LOCAL PARA ESTA TAREA",
+  repoHelp: `Pudu Agent Lab \u2014 b\xFAsqueda, grafo y harness
 
 Uso:
   npx pudu-ai repo search CONSULTA
   npx pudu-ai repo search CONSULTA --repo RUTA --json
   npx pudu-ai repo search --structural 'def $FUNC($$$ARGS): $$$BODY'
+  npx pudu-ai repo graph --repo RUTA
+  npx pudu-ai repo harness --task "arreglar auth" --repo RUTA --json
 
 Flags:
-  --repo PATH         Ra\xEDz del repositorio (por defecto: cwd)
-  --structural PAT    Patr\xF3n de ast-grep
+  --repo PATH         Ra\xEDz del repositorio (cwd)
+  --structural PAT    Patr\xF3n ast-grep
   --intent INTENT     TEXT | STRUCTURAL | RELATIONSHIP | IMPACT | SEMANTIC | UNKNOWN
   --glob GLOB         Glob de inclusi\xF3n (repetible)
   --limit N           M\xE1ximo de coincidencias (100)
-  --json              SearchResult legible por m\xE1quinas
+  --task TEXT         Prompt de la tarea harness
+  --json              JSON
 `,
   nav: "[S] Setup/Instalar  [B] Benchmark  [M] Modelos  [R] Recomendaciones  [T] Tareas  [H] Hardware  [C] Comparar  [L] Historial  [Q] Salir",
   setupTitle: "SETUP \u2014 INSTALAR MODELOS Y AGENTES",
@@ -423,6 +462,8 @@ Uso:
   npx pudu-ai launch opencode --yes
   npx pudu-ai repo search CONSULTA
   npx pudu-ai repo search --structural 'def $FUNC($$$ARGS): $$$BODY'
+  npx pudu-ai repo graph
+  npx pudu-ai repo harness --task "arreglar auth"
 
 Flags:
   --json          JSON legible por m\xE1quinas (sin TUI)

package/dist/cli/chunk-LL5FQT7I.js

@@ -0,0 +1,78 @@
+import {
+  commandExists,
+  runCommand
+} from "./chunk-SS7OXXQQ.js";
+
+// src/agent-lab/python-bridge.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function hasEngine(dir) {
+  return existsSync(path.join(dir, "pudu_agent", "__main__.py"));
+}
+function pythonRoot() {
+  const starts = [path.dirname(fileURLToPath(import.meta.url)), process.cwd()];
+  for (const start of starts) {
+    let dir = start;
+    for (let i = 0; i < 8; i++) {
+      const candidate = path.join(dir, "python");
+      if (hasEngine(candidate)) return candidate;
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "python");
+}
+async function findPython() {
+  return await commandExists("python3") ?? await commandExists("python");
+}
+async function invokePuduAgent(request, timeout = 3e4) {
+  const python = await findPython();
+  if (!python) {
+    throw new Error("python3 not found on PATH");
+  }
+  const root = pythonRoot();
+  const payload = `${JSON.stringify(request)}
+`;
+  const result = await runCommand(python, ["-m", "pudu_agent"], {
+    cwd: root,
+    env: { ...process.env, PYTHONPATH: root, PYTHONUNBUFFERED: "1" },
+    input: payload,
+    timeout
+  });
+  return { ...result, python };
+}
+function parseJsonStdout(stdout) {
+  const text = stdout.trim();
+  if (!text) {
+    throw new Error("Python engine returned empty stdout");
+  }
+  const start = text.indexOf("{");
+  const slice = start >= 0 ? text.slice(start) : text;
+  return JSON.parse(slice);
+}
+
+// src/agent-lab/graph.ts
+async function buildRepoGraph(repo, timeoutMs = 6e4) {
+  const invoked = await invokePuduAgent({ op: "graph", repo }, timeoutMs);
+  if (invoked.timedOut) throw new Error("Python graph engine timed out");
+  const parsed = parseJsonStdout(invoked.stdout);
+  if (!parsed || parsed.ok === false) {
+    throw new Error(parsed.error ?? "graph failed");
+  }
+  return parsed;
+}
+async function runRepoHarness(repo, task, timeoutMs = 6e4) {
+  const invoked = await invokePuduAgent({ op: "harness", repo, task }, timeoutMs);
+  if (invoked.timedOut) throw new Error("Python harness engine timed out");
+  return parseJsonStdout(invoked.stdout);
+}
+
+export {
+  findPython,
+  invokePuduAgent,
+  parseJsonStdout,
+  buildRepoGraph,
+  runRepoHarness
+};

package/dist/cli/{chunk-6C5EPKRI.js → chunk-PX7BJDD3.js}

@@ -3,7 +3,7 @@ import {
   formatTokensPerSec,
   na,
   t
-} from "./chunk-QGEXKMQ5.js";
+} from "./chunk-6NXOK4OD.js";
 import {
   commandExists,
   runCommand,

package/dist/cli/index.js

@@ -32,12 +32,12 @@ import {
   runBenchmark,
   runtimesText,
   tasksText
-} from "./chunk-6C5EPKRI.js";
+} from "./chunk-PX7BJDD3.js";
 import {
   resolveLocale,
   setLocale,
   t
-} from "./chunk-QGEXKMQ5.js";
+} from "./chunk-6NXOK4OD.js";
 import {
   commandExists,
   killAll,
@@ -57,7 +57,8 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "--repo",
   "--intent",
   "--limit",
-  "--glob"
+  "--glob",
+  "--task"
 ]);
 function flagValue(args2, name) {
   const index = args2.findIndex((a) => a === name);
@@ -131,7 +132,8 @@ function parseArgs(argv) {
     repo: flagValue(args2, "--repo"),
     intent: flagValue(args2, "--intent"),
     limit,
-    globs: flagValues(args2, "--glob")
+    globs: flagValues(args2, "--glob"),
+    task: flagValue(args2, "--task")
   };
 }
 
@@ -726,7 +728,7 @@ ${modelsText(session)}`)}
     );
     return;
   }
-  const { renderDashboard } = await import("./render-3UBPZNF4.js");
+  const { renderDashboard } = await import("./render-SKZLGUOW.js");
   await renderDashboard(session, preset, start);
 }
 async function run(args2) {
@@ -739,7 +741,7 @@ async function run(args2) {
   if (args2.verbose) setLogLevel("verbose");
   if (!args2.color) process.env.NO_COLOR = "1";
   if (args2.command === "repo") {
-    const { runRepoCommand } = await import("./repo-cli-4GSG5MD3.js");
+    const { runRepoCommand } = await import("./repo-cli-TPYCTV5J.js");
     return runRepoCommand(args2);
   }
   const cleanup = () => {

package/dist/cli/{render-3UBPZNF4.js → render-SKZLGUOW.js}

@@ -16,21 +16,24 @@ import {
   resultText,
   runBenchmark,
   tasksText
-} from "./chunk-6C5EPKRI.js";
+} from "./chunk-PX7BJDD3.js";
+import {
+  buildRepoGraph
+} from "./chunk-LL5FQT7I.js";
 import {
   formatNumber,
   formatPercent,
   formatTokensPerSec,
   t
-} from "./chunk-QGEXKMQ5.js";
+} from "./chunk-6NXOK4OD.js";
 import "./chunk-SS7OXXQQ.js";
 
 // src/tui/render.tsx
 import { render } from "ink";
 
 // src/tui/App.tsx
-import { useApp as useApp2, useInput as useInput4 } from "ink";
-import { useMemo as useMemo2, useRef as useRef2, useState as useState4 } from "react";
+import { useApp as useApp2, useInput as useInput5 } from "ink";
+import { useMemo as useMemo3, useRef as useRef2, useState as useState5 } from "react";
 
 // src/tui/views/Dashboard.tsx
 import { Box as Box2, Text as Text2 } from "ink";
@@ -84,6 +87,7 @@ var NAV = [
   { key: "M", label: "Models", color: "cyan" },
   { key: "R", label: "Rec", color: "magenta" },
   { key: "T", label: "Tasks", color: "blue" },
+  { key: "G", label: "Graph", color: "magenta" },
   { key: "H", label: "HW", color: "white" },
   { key: "C", label: "Cmp", color: "green" },
   { key: "L", label: "Log", color: "cyan" },
@@ -729,6 +733,194 @@ function TasksView({ session }) {
   ] });
 }
 
+// src/tui/views/Graph.tsx
+import { Box as Box10, Text as Text11, useInput as useInput4 } from "ink";
+import { useEffect as useEffect2, useMemo as useMemo2, useState as useState4 } from "react";
+
+// src/agent-lab/harness.ts
+var GRADE_RANK = { S: 0, A: 1, B: 2, C: 3, D: 4, F: 5 };
+function isCodeish(useCase) {
+  const cases = useCase ?? ["chat", "code"];
+  return cases.some((item) => item.includes("code") || item.includes("chat"));
+}
+function pickHarnessModel(session, effort) {
+  const rows = session.rows.filter((row) => isCodeish(row.catalog?.useCase));
+  const pool = rows.length ? rows : session.rows;
+  if (!pool.length) {
+    return {
+      modelId: null,
+      modelName: null,
+      grade: null,
+      measuredTps: null,
+      reason: "No installed models. N/A",
+      origin: null
+    };
+  }
+  const scored = pool.map((row) => ({
+    row,
+    grade: row.compatibility?.grade ?? "C",
+    tps: row.lastBenchmark?.benchmark.generationTokensPerSecond ?? null,
+    params: row.catalog?.paramsBillions ?? null
+  }));
+  scored.sort((a, b) => {
+    if (effort.label === "LOW") {
+      if (a.tps != null && b.tps != null && a.tps !== b.tps) return b.tps - a.tps;
+      if (a.tps != null && b.tps == null) return -1;
+      if (a.tps == null && b.tps != null) return 1;
+      return (GRADE_RANK[a.grade] ?? 9) - (GRADE_RANK[b.grade] ?? 9);
+    }
+    if (effort.label === "HIGH" || effort.label === "VERY_HIGH") {
+      if (a.params != null && b.params != null && a.params !== b.params) return b.params - a.params;
+      if (a.params != null && b.params == null) return -1;
+      if (a.params == null && b.params != null) return 1;
+      return (GRADE_RANK[a.grade] ?? 9) - (GRADE_RANK[b.grade] ?? 9);
+    }
+    const grade = (GRADE_RANK[a.grade] ?? 9) - (GRADE_RANK[b.grade] ?? 9);
+    if (grade !== 0) return grade;
+    if (a.tps != null && b.tps != null) return b.tps - a.tps;
+    return 0;
+  });
+  const best = scored[0];
+  const reasons = {
+    LOW: "LOW effort: prefer fastest measured local coding model; else best grade.",
+    MEDIUM: "MEDIUM effort: prefer best hardware grade, then measured t/s.",
+    HIGH: "HIGH effort: prefer larger catalog params when known; else best grade.",
+    VERY_HIGH: "VERY_HIGH effort: prefer larger catalog params when known; else best grade."
+  };
+  return {
+    modelId: best.row.local.id,
+    modelName: best.row.local.name,
+    grade: best.grade,
+    measuredTps: best.tps,
+    reason: reasons[effort.label],
+    origin: "DERIVED"
+  };
+}
+
+// src/tui/views/Graph.tsx
+import { Fragment as Fragment6, jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+function GraphView({ session }) {
+  const [phase, setPhase] = useState4("build");
+  const [graph, setGraph] = useState4();
+  const [error, setError] = useState4("");
+  const [prompt, setPrompt] = useState4("");
+  const repo = process.cwd();
+  useEffect2(() => {
+    let live = true;
+    void (async () => {
+      try {
+        const result = await buildRepoGraph(repo);
+        if (!live) return;
+        setGraph(result);
+        setPhase("prompt");
+      } catch (err) {
+        if (!live) return;
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+      }
+    })();
+    return () => {
+      live = false;
+    };
+  }, [repo]);
+  useInput4((input, key) => {
+    if (phase !== "prompt") return;
+    if (key.return) {
+      setPhase("done");
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setPrompt((value) => value.slice(0, -1));
+      return;
+    }
+    if (input && !key.ctrl && !key.meta && input !== "	") {
+      setPrompt((value) => `${value}${input}`.slice(0, 240));
+    }
+  });
+  const pick = useMemo2(() => graph ? pickHarnessModel(session, graph.effort) : void 0, [graph, session]);
+  if (phase === "build") {
+    return /* @__PURE__ */ jsxs11(Panel, { title: t("repoGraphTitle"), color: "magenta", children: [
+      /* @__PURE__ */ jsx11(Text11, { children: t("repoGraphBuilding") }),
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: repo })
+    ] });
+  }
+  if (phase === "error") {
+    return /* @__PURE__ */ jsx11(Panel, { title: t("repoGraphTitle"), color: "magenta", children: /* @__PURE__ */ jsx11(Text11, { color: "red", children: error }) });
+  }
+  if (!graph) return /* @__PURE__ */ jsx11(Text11, { children: " " });
+  const degree = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    degree.set(edge.source, (degree.get(edge.source) ?? 0) + 1);
+  }
+  const top = [...graph.nodes].filter((node) => node.type === "file" || node.type === "function" || node.type === "test").sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0)).slice(0, 8);
+  return /* @__PURE__ */ jsxs11(Fragment6, { children: [
+    /* @__PURE__ */ jsxs11(Panel, { title: t("repoGraphTitle"), color: "magenta", children: [
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: fit(graph.repo, 80) }),
+      /* @__PURE__ */ jsxs11(Text11, { children: [
+        t("repoGraphFiles"),
+        " ",
+        graph.metrics.fileCount,
+        "  ",
+        t("repoGraphNodes"),
+        " ",
+        graph.metrics.nodeCount,
+        "  ",
+        t("repoGraphEdges"),
+        " ",
+        graph.metrics.edgeCount,
+        "  (",
+        graph.metrics.origin,
+        ")"
+      ] }),
+      top.map((node) => /* @__PURE__ */ jsxs11(Box10, { children: [
+        /* @__PURE__ */ jsx11(Text11, { color: "cyan", children: fit(node.file ?? node.name, 36) }),
+        /* @__PURE__ */ jsxs11(Text11, { children: [
+          "  ",
+          fit(node.name, 18),
+          "  "
+        ] }),
+        /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: degree.get(node.id) ?? 0 })
+      ] }, node.id)),
+      !top.length ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: t("repoGraphEmpty") }) : null
+    ] }),
+    /* @__PURE__ */ jsxs11(Panel, { title: t("repoEffortTitle"), color: "yellow", children: [
+      /* @__PURE__ */ jsxs11(Text11, { children: [
+        graph.effort.label,
+        "  ",
+        graph.effort.score0to100,
+        "/100  (",
+        graph.effort.origin,
+        ")"
+      ] }),
+      /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+        t("repoTokens"),
+        " ",
+        graph.metrics.tokenEstimate ?? "N/A",
+        " (",
+        graph.metrics.tokenOrigin ?? "N/A",
+        ")"
+      ] })
+    ] }),
+    phase === "prompt" ? /* @__PURE__ */ jsxs11(Panel, { title: t("repoHarnessPrompt"), color: "blue", children: [
+      /* @__PURE__ */ jsxs11(Text11, { children: [
+        prompt || t("repoHarnessPromptHint"),
+        /* @__PURE__ */ jsx11(Text11, { color: "cyan", children: "\u258D" })
+      ] }),
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: t("repoHarnessEnter") })
+    ] }) : /* @__PURE__ */ jsxs11(Panel, { title: t("repoHarnessModel"), color: "green", children: [
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: prompt || t("repoHarnessNoPrompt") }),
+      pick?.modelName ? /* @__PURE__ */ jsxs11(Text11, { children: [
+        pick.modelName,
+        "  ",
+        pick.grade ?? "\u2014",
+        "  ",
+        pick.measuredTps != null ? `${pick.measuredTps} t/s` : t("notTested")
+      ] }) : /* @__PURE__ */ jsx11(Text11, { color: "yellow", children: pick?.reason ?? "N/A" }),
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: pick?.reason })
+    ] })
+  ] });
+}
+
 // src/tui/keys.ts
 function globalNav(letter) {
   if (letter === "b") return { type: "screen", screen: "benchmark" };
@@ -739,11 +931,16 @@ function globalNav(letter) {
   if (letter === "l") return { type: "screen", screen: "history" };
   if (letter === "t") return { type: "screen", screen: "tasks" };
   if (letter === "s") return { type: "screen", screen: "setup" };
+  if (letter === "g") return { type: "screen", screen: "graph" };
   return void 0;
 }
 function handleAppKey(screen, input, key) {
   const letter = input.toLowerCase();
   if (screen === "benchmark") return { type: "ignore" };
+  if (screen === "graph") {
+    if (key.escape) return { type: "home" };
+    return { type: "ignore" };
+  }
   if (letter === "q") return { type: "quit" };
   if (key.escape) return screen === "home" ? { type: "quit" } : { type: "home" };
   if (screen === "setup") {
@@ -757,34 +954,35 @@ function handleAppKey(screen, input, key) {
 }
 
 // src/tui/App.tsx
-import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
 function App(props) {
   const { exit } = useApp2();
-  const [screen, setScreen] = useState4(props.start ?? "home");
+  const [screen, setScreen] = useState5(props.start ?? "home");
   const screenRef = useRef2(screen);
   screenRef.current = screen;
-  const [selected, setSelected] = useState4(0);
-  const benchable = useMemo2(
+  const [selected, setSelected] = useState5(0);
+  const benchable = useMemo3(
     () => props.session.models.filter((m) => Boolean(m.artifactPath)),
     [props.session.models]
   );
-  useInput4((input, key) => {
+  useInput5((input, key) => {
     const result = handleAppKey(screenRef.current, input, key);
     if (result.type === "quit") exit();
     if (result.type === "home") setScreen("home");
     if (result.type === "screen") setScreen(result.screen);
   });
-  return /* @__PURE__ */ jsxs11(Frame, { children: [
-    screen !== "benchmark" && /* @__PURE__ */ jsx11(Header, {}),
-    screen === "home" && /* @__PURE__ */ jsx11(Dashboard, { session: props.session }),
-    screen === "models" && /* @__PURE__ */ jsx11(ModelsView, { session: props.session }),
-    screen === "hardware" && /* @__PURE__ */ jsx11(HardwareView, { session: props.session }),
-    screen === "recommend" && /* @__PURE__ */ jsx11(RecommendView, { session: props.session }),
-    screen === "setup" && /* @__PURE__ */ jsx11(SetupView, { session: props.session }),
-    screen === "compare" && /* @__PURE__ */ jsx11(CompareView, { session: props.session }),
-    screen === "history" && /* @__PURE__ */ jsx11(HistoryView, { session: props.session }),
-    screen === "tasks" && /* @__PURE__ */ jsx11(TasksView, { session: props.session }),
-    screen === "benchmark" && /* @__PURE__ */ jsx11(
+  return /* @__PURE__ */ jsxs12(Frame, { children: [
+    screen !== "benchmark" && /* @__PURE__ */ jsx12(Header, {}),
+    screen === "home" && /* @__PURE__ */ jsx12(Dashboard, { session: props.session }),
+    screen === "models" && /* @__PURE__ */ jsx12(ModelsView, { session: props.session }),
+    screen === "hardware" && /* @__PURE__ */ jsx12(HardwareView, { session: props.session }),
+    screen === "recommend" && /* @__PURE__ */ jsx12(RecommendView, { session: props.session }),
+    screen === "setup" && /* @__PURE__ */ jsx12(SetupView, { session: props.session }),
+    screen === "compare" && /* @__PURE__ */ jsx12(CompareView, { session: props.session }),
+    screen === "history" && /* @__PURE__ */ jsx12(HistoryView, { session: props.session }),
+    screen === "tasks" && /* @__PURE__ */ jsx12(TasksView, { session: props.session }),
+    screen === "graph" && /* @__PURE__ */ jsx12(GraphView, { session: props.session }),
+    screen === "benchmark" && /* @__PURE__ */ jsx12(
       BenchmarkView,
       {
         session: props.session,
@@ -799,9 +997,9 @@ function App(props) {
 }
 
 // src/tui/render.tsx
-import { jsx as jsx12 } from "react/jsx-runtime";
+import { jsx as jsx13 } from "react/jsx-runtime";
 async function renderDashboard(session, preset, start) {
-  const instance = render(/* @__PURE__ */ jsx12(App, { session, preset, start }), {
+  const instance = render(/* @__PURE__ */ jsx13(App, { session, preset, start }), {
     exitOnCtrlC: true,
     patchConsole: true
   });

package/dist/cli/{repo-cli-4GSG5MD3.js → repo-cli-TPYCTV5J.js}

@@ -1,64 +1,18 @@
+import {
+  buildRepoGraph,
+  findPython,
+  invokePuduAgent,
+  parseJsonStdout,
+  runRepoHarness
+} from "./chunk-LL5FQT7I.js";
 import {
   na,
   t
-} from "./chunk-QGEXKMQ5.js";
-import {
-  commandExists,
-  runCommand
-} from "./chunk-SS7OXXQQ.js";
+} from "./chunk-6NXOK4OD.js";
+import "./chunk-SS7OXXQQ.js";
 
 // src/agent-lab/repo-cli.ts
-import path2 from "node:path";
-
-// src/agent-lab/python-bridge.ts
-import { existsSync } from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-function hasEngine(dir) {
-  return existsSync(path.join(dir, "pudu_agent", "__main__.py"));
-}
-function pythonRoot() {
-  const starts = [path.dirname(fileURLToPath(import.meta.url)), process.cwd()];
-  for (const start of starts) {
-    let dir = start;
-    for (let i = 0; i < 8; i++) {
-      const candidate = path.join(dir, "python");
-      if (hasEngine(candidate)) return candidate;
-      const parent = path.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-  }
-  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "python");
-}
-async function findPython() {
-  return await commandExists("python3") ?? await commandExists("python");
-}
-async function invokePuduAgent(request, timeout = 3e4) {
-  const python = await findPython();
-  if (!python) {
-    throw new Error("python3 not found on PATH");
-  }
-  const root = pythonRoot();
-  const payload = `${JSON.stringify(request)}
-`;
-  const result = await runCommand(python, ["-m", "pudu_agent"], {
-    cwd: root,
-    env: { ...process.env, PYTHONPATH: root, PYTHONUNBUFFERED: "1" },
-    input: payload,
-    timeout
-  });
-  return { ...result, python };
-}
-function parseJsonStdout(stdout) {
-  const text = stdout.trim();
-  if (!text) {
-    throw new Error("Python engine returned empty stdout");
-  }
-  const start = text.indexOf("{");
-  const slice = start >= 0 ? text.slice(start) : text;
-  return JSON.parse(slice);
-}
 
 // src/agent-lab/schema.ts
 import { z } from "zod";
@@ -83,7 +37,7 @@ var searchMatchSchema = z.object({
   endLine: z.number().nullable(),
   endColumn: z.number().nullable(),
   text: z.string(),
-  strategy: z.enum(["rg", "ast-grep"]),
+  strategy: z.enum(["rg", "ast-grep", "graph"]),
   language: z.string().nullable(),
   metavariables: z.record(z.string())
 });
@@ -205,16 +159,41 @@ async function runRepoCommand(args) {
     print(t("repoHelp"), args.json);
     return 0;
   }
+  const python = await findPython();
+  if (!python) {
+    process.stderr.write(`${t("repoPythonMissing")}
+`);
+    return 1;
+  }
+  const repo = path.resolve(args.repo ?? process.cwd());
+  if (sub === "graph") {
+    try {
+      const graph = await buildRepoGraph(repo);
+      print(args.json ? graph : formatGraphText(graph), args.json);
+      return graph.ok ? 0 : 1;
+    } catch (error) {
+      return fail(error, args.json);
+    }
+  }
+  if (sub === "harness") {
+    const task = args.task ?? args.positional.slice(1).join(" ").trim() ?? "";
+    if (!task) {
+      process.stderr.write(`${t("repoNeedTask")}
+`);
+      return 1;
+    }
+    try {
+      const harness = await runRepoHarness(repo, task);
+      print(args.json ? harness : formatGraphText(harness.graph, task), args.json);
+      return harness.ok ? 0 : 1;
+    } catch (error) {
+      return fail(error, args.json);
+    }
+  }
   if (sub !== "search") {
     process.stderr.write(`${t("repoUnknownSubcommand", { sub })}
 `);
     process.stderr.write(`${t("repoHelp")}
-`);
-    return 1;
-  }
-  const python = await findPython();
-  if (!python) {
-    process.stderr.write(`${t("repoPythonMissing")}
 `);
     return 1;
   }
@@ -226,7 +205,6 @@ async function runRepoCommand(args) {
     return 1;
   }
   const intent = asIntent(args.intent);
-  const repo = path2.resolve(args.repo ?? process.cwd());
   try {
     const result = await searchRepo({
       repo,
@@ -239,17 +217,54 @@ async function runRepoCommand(args) {
     print(args.json ? result : formatSearchText(result), args.json);
     return result.ok ? 0 : 1;
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (args.json) {
-      print({ ok: false, error: message }, true);
-    } else {
-      process.stderr.write(`${message}
+    return fail(error, args.json);
+  }
+}
+function fail(error, json) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (json) print({ ok: false, error: message }, true);
+  else process.stderr.write(`${message}
 `);
-    }
-    return 1;
+  return 1;
+}
+function formatGraphText(graph, task) {
+  const e = graph.effort;
+  const m = graph.metrics;
+  const lines = [
+    t("repoGraphTitle"),
+    "",
+    t("aboutRepoGraph"),
+    "",
+    `Repo       ${graph.repo}`,
+    `Backend    ${graph.backend}`,
+    `Files      ${m.fileCount}  (${m.origin})`,
+    `Nodes      ${m.nodeCount}  (${m.origin})`,
+    `Edges      ${m.edgeCount}  (${m.origin})`,
+    `Tokens     ${m.tokenEstimate ?? "N/A"}  (${m.tokenOrigin ?? "N/A"})`,
+    `Effort     ${e.label}  ${e.score0to100}/100  (${e.origin})`
+  ];
+  if (task) lines.push(`Task       ${task}`);
+  if (graph.writtenTo) lines.push(`Wrote      ${graph.writtenTo}`);
+  for (const err of graph.errors) {
+    lines.push(`Error      ${err.tool}: ${err.message}  (${err.origin})`);
+  }
+  lines.push("");
+  const degree = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    degree.set(edge.source, (degree.get(edge.source) ?? 0) + 1);
+    degree.set(edge.target, (degree.get(edge.target) ?? 0) + 1);
   }
+  const top = [...graph.nodes].filter((n) => n.type === "file" || n.type === "function" || n.type === "test").sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0)).slice(0, 12);
+  for (const node of top) {
+    const related = graph.edges.filter((edge) => edge.source === node.id).slice(0, 3).map((edge) => `${edge.type}\u2192${edge.symbol ?? edge.target} [${edge.confidence}]`);
+    lines.push(`${node.file ?? node.name}  ${node.name}  (${degree.get(node.id) ?? 0})`);
+    for (const rel of related) lines.push(`  ${rel}`);
+  }
+  if (!top.length) lines.push(t("repoGraphEmpty"));
+  return lines.join("\n");
 }
 export {
+  formatGraphText,
   formatSearchText,
   runRepoCommand
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pudu-ai",
-  "version": "0.2.21",
+  "version": "0.2.22",
   "description": "Pudu-AI — local AI hardware & benchmark lab for the terminal",
   "keywords": [
     "ai",

package/python/pudu_agent/graph.py

@@ -0,0 +1,398 @@
+from __future__ import annotations
+
+import ast
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+SKIP_DIRS = {
+    ".git",
+    "node_modules",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".pudu-ai",
+    "dist",
+    "build",
+    ".tox",
+    ".mypy_cache",
+}
+MAX_FILES = 500
+MAX_EDGES = 3000
+MAX_BYTES = 400_000
+
+
+def graph_tool_info() -> dict[str, Any]:
+    return {"available": True, "path": "python-ast", "version": "stdlib"}
+
+
+def _rel(repo: Path, path: Path) -> str:
+    try:
+        return str(path.relative_to(repo)).replace("\\", "/")
+    except ValueError:
+        return str(path)
+
+
+def _iter_py_files(repo: Path) -> list[Path]:
+    files: list[Path] = []
+    for path in repo.rglob("*.py"):
+        if any(part in SKIP_DIRS for part in path.parts):
+            continue
+        if not path.is_file():
+            continue
+        files.append(path)
+        if len(files) >= MAX_FILES:
+            break
+    return files
+
+
+def _module_name(rel: str) -> str:
+    body = rel[:-3] if rel.endswith(".py") else rel
+    if body.endswith("/__init__"):
+        body = body[: -len("/__init__")]
+    return body.replace("/", ".")
+
+
+def _is_test(rel: str) -> bool:
+    name = Path(rel).name
+    return name.startswith("test_") or name.endswith("_test.py") or "/tests/" in f"/{rel}/"
+
+
+def _load_graphify(repo: Path) -> tuple[list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]]]:
+    path = repo / "graphify-out" / "graph.json"
+    if not path.is_file():
+        return [], [], []
+    try:
+        raw = json.loads(path.read_text(encoding="utf8"))
+    except (OSError, ValueError) as exc:
+        return [], [], [{"tool": "graphify", "message": str(exc), "origin": "MEASURED"}]
+    nodes_in = raw.get("nodes") if isinstance(raw, dict) else None
+    edges_in = raw.get("edges") if isinstance(raw, dict) else None
+    if not isinstance(nodes_in, list) or not isinstance(edges_in, list):
+        return [], [], [{"tool": "graphify", "message": "graphify-out/graph.json missing nodes/edges arrays", "origin": "MEASURED"}]
+    nodes: list[dict[str, Any]] = []
+    for item in nodes_in:
+        if not isinstance(item, dict):
+            continue
+        ident = item.get("id") or item.get("name")
+        if not isinstance(ident, str):
+            continue
+        kind = item.get("type") or item.get("kind") or "file"
+        nodes.append(
+            {
+                "id": ident,
+                "type": kind if isinstance(kind, str) else "file",
+                "name": item.get("name") if isinstance(item.get("name"), str) else ident,
+                "file": item.get("file") if isinstance(item.get("file"), str) else None,
+                "line": item.get("line") if isinstance(item.get("line"), int) else None,
+                "backend": "graphify",
+            }
+        )
+    edges: list[dict[str, Any]] = []
+    allowed = {"imports", "calls", "inherits", "references", "definitions"}
+    for item in edges_in:
+        if not isinstance(item, dict):
+            continue
+        source = item.get("source") or item.get("from")
+        target = item.get("target") or item.get("to")
+        kind = item.get("type") or item.get("kind") or item.get("relation")
+        if not isinstance(source, str) or not isinstance(target, str) or not isinstance(kind, str):
+            continue
+        if kind not in allowed:
+            continue
+        edges.append(
+            {
+                "source": source,
+                "target": target,
+                "type": kind,
+                "confidence": "EXTRACTED",
+                "file": item.get("file") if isinstance(item.get("file"), str) else None,
+                "line": item.get("line") if isinstance(item.get("line"), int) else None,
+                "symbol": item.get("symbol") if isinstance(item.get("symbol"), str) else None,
+                "backend": "graphify",
+            }
+        )
+    return nodes, edges, []
+
+
+def build_python_graph(repo: Path) -> tuple[list[dict[str, Any]], list[dict[str, Any]], int, list[dict[str, Any]]]:
+    nodes: list[dict[str, Any]] = []
+    edges: list[dict[str, Any]] = []
+    errors: list[dict[str, Any]] = []
+    chars = 0
+    seen_nodes: set[str] = set()
+
+    def add_node(node: dict[str, Any]) -> None:
+        ident = node["id"]
+        if ident in seen_nodes:
+            return
+        seen_nodes.add(ident)
+        nodes.append(node)
+
+    for path in _iter_py_files(repo):
+        rel = _rel(repo, path)
+        try:
+            source = path.read_text(encoding="utf8", errors="replace")
+        except OSError as exc:
+            errors.append({"tool": "python-ast", "message": f"{rel}: {exc}", "origin": "MEASURED"})
+            continue
+        if len(source) > MAX_BYTES:
+            errors.append({"tool": "python-ast", "message": f"{rel}: skipped, file larger than {MAX_BYTES} bytes", "origin": "MEASURED"})
+            continue
+        chars += len(source)
+        try:
+            tree = ast.parse(source, filename=rel)
+        except SyntaxError as exc:
+            errors.append({"tool": "python-ast", "message": f"{rel}: {exc.msg}", "origin": "MEASURED"})
+            continue
+
+        file_id = f"file:{rel}"
+        mod_id = f"module:{_module_name(rel)}"
+        add_node({"id": file_id, "type": "test" if _is_test(rel) else "file", "name": rel, "file": rel, "line": 1, "backend": "python-ast"})
+        add_node({"id": mod_id, "type": "module", "name": _module_name(rel), "file": rel, "line": 1, "backend": "python-ast"})
+        edges.append(
+            {
+                "source": file_id,
+                "target": mod_id,
+                "type": "definitions",
+                "confidence": "EXTRACTED",
+                "file": rel,
+                "line": 1,
+                "symbol": _module_name(rel),
+                "backend": "python-ast",
+            }
+        )
+
+        defs: dict[str, str] = {}
+        current_fn: str | None = None
+
+        class Visitor(ast.NodeVisitor):
+            def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+                nonlocal current_fn
+                ident = f"def:{rel}:{node.name}"
+                add_node({"id": ident, "type": "function", "name": node.name, "file": rel, "line": node.lineno, "backend": "python-ast"})
+                defs[node.name] = ident
+                edges.append(
+                    {
+                        "source": file_id,
+                        "target": ident,
+                        "type": "definitions",
+                        "confidence": "EXTRACTED",
+                        "file": rel,
+                        "line": node.lineno,
+                        "symbol": node.name,
+                        "backend": "python-ast",
+                    }
+                )
+                prev = current_fn
+                current_fn = ident
+                self.generic_visit(node)
+                current_fn = prev
+
+            def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+                self.visit_FunctionDef(node)  # type: ignore[arg-type]
+
+            def visit_ClassDef(self, node: ast.ClassDef) -> None:
+                ident = f"class:{rel}:{node.name}"
+                add_node({"id": ident, "type": "class", "name": node.name, "file": rel, "line": node.lineno, "backend": "python-ast"})
+                defs[node.name] = ident
+                edges.append(
+                    {
+                        "source": file_id,
+                        "target": ident,
+                        "type": "definitions",
+                        "confidence": "EXTRACTED",
+                        "file": rel,
+                        "line": node.lineno,
+                        "symbol": node.name,
+                        "backend": "python-ast",
+                    }
+                )
+                for base in node.bases:
+                    name = base.id if isinstance(base, ast.Name) else None
+                    if not name:
+                        continue
+                    target = defs.get(name, f"name:{name}")
+                    if target.startswith("name:"):
+                        add_node({"id": target, "type": "name", "name": name, "file": None, "line": None, "backend": "python-ast"})
+                    edges.append(
+                        {
+                            "source": ident,
+                            "target": target,
+                            "type": "inherits",
+                            "confidence": "EXTRACTED" if target in defs.values() else "EXTRACTED",
+                            "file": rel,
+                            "line": node.lineno,
+                            "symbol": name,
+                            "backend": "python-ast",
+                        }
+                    )
+                self.generic_visit(node)
+
+            def visit_Import(self, node: ast.Import) -> None:
+                for alias in node.names:
+                    target = f"module:{alias.name}"
+                    add_node({"id": target, "type": "module", "name": alias.name, "file": None, "line": None, "backend": "python-ast"})
+                    edges.append(
+                        {
+                            "source": file_id,
+                            "target": target,
+                            "type": "imports",
+                            "confidence": "EXTRACTED",
+                            "file": rel,
+                            "line": node.lineno,
+                            "symbol": alias.name,
+                            "backend": "python-ast",
+                        }
+                    )
+
+            def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+                if not node.module:
+                    return
+                target = f"module:{node.module}"
+                add_node({"id": target, "type": "module", "name": node.module, "file": None, "line": None, "backend": "python-ast"})
+                edges.append(
+                    {
+                        "source": file_id,
+                        "target": target,
+                        "type": "imports",
+                        "confidence": "EXTRACTED",
+                        "file": rel,
+                        "line": node.lineno,
+                        "symbol": node.module,
+                        "backend": "python-ast",
+                    }
+                )
+
+            def visit_Call(self, node: ast.Call) -> None:
+                name: str | None = None
+                if isinstance(node.func, ast.Name):
+                    name = node.func.id
+                elif isinstance(node.func, ast.Attribute):
+                    name = node.func.attr
+                if name and current_fn:
+                    target = defs.get(name, f"name:{name}")
+                    confidence = "RESOLVED" if name in defs else "EXTRACTED"
+                    if target.startswith("name:"):
+                        add_node({"id": target, "type": "name", "name": name, "file": None, "line": None, "backend": "python-ast"})
+                    edges.append(
+                        {
+                            "source": current_fn,
+                            "target": target,
+                            "type": "calls",
+                            "confidence": confidence,
+                            "file": rel,
+                            "line": getattr(node, "lineno", None),
+                            "symbol": name,
+                            "backend": "python-ast",
+                        }
+                    )
+                self.generic_visit(node)
+
+        Visitor().visit(tree)
+        if len(edges) >= MAX_EDGES:
+            errors.append({"tool": "python-ast", "message": f"edge cap {MAX_EDGES} reached", "origin": "MEASURED"})
+            break
+
+    return nodes, edges[:MAX_EDGES], chars, errors
+
+
+def effort_from_counts(file_count: int, edge_count: int, token_estimate: int) -> dict[str, Any]:
+    score = min(100, int(round(file_count * 1.2 + edge_count * 0.15 + token_estimate / 800)))
+    if score < 20:
+        label = "LOW"
+    elif score < 45:
+        label = "MEDIUM"
+    elif score < 75:
+        label = "HIGH"
+    else:
+        label = "VERY_HIGH"
+    return {
+        "label": label,
+        "score0to100": score,
+        "origin": "DERIVED",
+        "humanBaselineMinutes": None,
+        "agentRuntimeMinutes": None,
+        "humanInterventionMinutes": None,
+        "potentialTimeReductionPct": None,
+    }
+
+
+def build_graph(repo: Path, persist: bool = True) -> dict[str, Any]:
+    started = time.perf_counter()
+    py_nodes, py_edges, chars, errors = build_python_graph(repo)
+    gy_nodes, gy_edges, gy_errors = _load_graphify(repo)
+    errors.extend(gy_errors)
+    nodes = py_nodes + gy_nodes
+    edges = py_edges + gy_edges
+    backend = "hybrid" if gy_nodes or gy_edges else "python-ast"
+    token_estimate = max(0, chars // 4)
+    file_count = sum(1 for n in py_nodes if n["type"] in {"file", "test"})
+    duration_ms = int((time.perf_counter() - started) * 1000)
+    payload = {
+        "schemaVersion": 1,
+        "ok": True,
+        "op": "graph",
+        "repo": str(repo),
+        "backend": backend,
+        "writtenTo": None,
+        "nodes": nodes,
+        "edges": edges,
+        "metrics": {
+            "fileCount": file_count,
+            "nodeCount": len(nodes),
+            "edgeCount": len(edges),
+            "tokenEstimate": token_estimate,
+            "tokenOrigin": "ESTIMATED",
+            "durationMs": duration_ms,
+            "origin": "MEASURED",
+        },
+        "effort": effort_from_counts(file_count, len(edges), token_estimate),
+        "errors": errors,
+        "tools": {"graph": graph_tool_info()},
+    }
+    if persist:
+        out_dir = repo / ".pudu-ai"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out = out_dir / "code-graph.json"
+        out.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf8")
+        payload["writtenTo"] = str(out)
+    return payload
+
+
+def query_graph(graph: dict[str, Any], query: str | None, limit: int) -> list[dict[str, Any]]:
+    if not query:
+        return []
+    needle = query.strip()
+    for prefix in ("who calls ", "callers of ", "impact of ", "dependencies of ", "imports of "):
+        if needle.lower().startswith(prefix):
+            needle = needle[len(prefix) :].strip()
+            break
+    needle = needle.split()[0] if needle.split() else needle
+    if not needle:
+        return []
+    matches: list[dict[str, Any]] = []
+    for edge in graph.get("edges") or []:
+        if not isinstance(edge, dict):
+            continue
+        symbol = edge.get("symbol") if isinstance(edge.get("symbol"), str) else ""
+        target = edge.get("target") if isinstance(edge.get("target"), str) else ""
+        if needle not in symbol and needle not in target:
+            continue
+        matches.append(
+            {
+                "file": edge.get("file") or "",
+                "line": edge.get("line") if isinstance(edge.get("line"), int) else None,
+                "column": None,
+                "endLine": edge.get("line") if isinstance(edge.get("line"), int) else None,
+                "endColumn": None,
+                "text": f"{edge.get('type')} {edge.get('source')} -> {edge.get('target')} [{edge.get('confidence')}]",
+                "strategy": "graph",
+                "language": "python",
+                "metavariables": {"symbol": symbol or needle},
+            }
+        )
+        if len(matches) >= limit:
+            break
+    return matches

package/python/pudu_agent/search.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import Any
 
 from pudu_agent.ast_search import run_ast_grep, tool_info as ast_tool_info
+from pudu_agent.graph import build_graph, graph_tool_info, query_graph
 from pudu_agent.protocol import (
     PROTOCOL_VERSION,
     classify_intent,
@@ -48,10 +49,6 @@ def rg_tool_info() -> dict[str, Any]:
     }
 
 
-def graph_tool_info() -> dict[str, Any]:
-    return {"available": False, "path": None, "version": None}
-
-
 def parse_rg_json_line(line: str) -> dict[str, Any] | None:
     line = line.strip()
     if not line:
@@ -222,16 +219,8 @@ def handle_search(req: dict[str, Any]) -> dict[str, Any]:
         result["ok"] = False
         return result
 
-    if intent in {"RELATIONSHIP", "IMPACT", "SEMANTIC"} or planned == ["graph"] or not planned:
+    if intent == "SEMANTIC" or not planned:
         duration_ms = int((time.perf_counter() - started) * 1000)
-        unavailable = ["graph"] if intent in {"RELATIONSHIP", "IMPACT"} else (["semantic"] if intent == "SEMANTIC" else planned)
-        errors = [
-            {
-                "tool": "graph" if intent != "SEMANTIC" else "semantic",
-                "message": "not implemented in Agent Lab iteration 1",
-                "origin": "MEASURED",
-            }
-        ]
         return empty_search(
             str(repo),
             query,
@@ -239,11 +228,39 @@ def handle_search(req: dict[str, Any]) -> dict[str, Any]:
             intent,
             strategy if planned else "hybrid",
             tools,
-            errors,
-            unavailable,
+            [{"tool": "semantic", "message": "semantic search is not implemented; no LLM router", "origin": "MEASURED"}],
+            ["semantic"],
             duration_ms,
         )
 
+    if intent in {"RELATIONSHIP", "IMPACT"} or planned == ["graph"]:
+        graph = build_graph(repo, persist=True)
+        duration_ms = int((time.perf_counter() - started) * 1000)
+        matches = query_graph(graph, query, limit)
+        errors = list(graph.get("errors") or [])
+        return {
+            "schemaVersion": PROTOCOL_VERSION,
+            "ok": True,
+            "op": "search",
+            "repo": str(repo),
+            "query": query,
+            "structuralPattern": structural,
+            "intent": intent,
+            "strategy": "graph",
+            "matches": matches,
+            "tools": tools,
+            "errors": errors,
+            "metrics": {
+                "durationMs": duration_ms,
+                "matchCount": len(matches),
+                "rgQueries": 0,
+                "astQueries": 0,
+                "graphQueries": 1,
+                "origin": "MEASURED",
+            },
+            "unavailable": [],
+        }
+
     matches: list[dict[str, Any]] = []
     errors: list[dict[str, Any]] = []
     unavailable: list[str] = []
@@ -330,6 +347,35 @@ def main() -> int:
             }
         )
         return 0
+    if op == "graph":
+        repo_raw = req.get("repo") or "."
+        repo = Path(repo_raw).expanduser().resolve()
+        if not repo.is_dir():
+            write_response(error_response("repo is not a directory", op="graph"))
+            return 1
+        result = build_graph(repo, persist=True)
+        write_response(result)
+        return 0
+    if op == "harness":
+        repo_raw = req.get("repo") or "."
+        repo = Path(repo_raw).expanduser().resolve()
+        task = req.get("task") if isinstance(req.get("task"), str) else None
+        if not repo.is_dir():
+            write_response(error_response("repo is not a directory", op="harness"))
+            return 1
+        graph = build_graph(repo, persist=True)
+        write_response(
+            {
+                "schemaVersion": PROTOCOL_VERSION,
+                "ok": True,
+                "op": "harness",
+                "repo": str(repo),
+                "task": task,
+                "graph": graph,
+                "effort": graph.get("effort"),
+            }
+        )
+        return 0
     if op != "search":
         write_response(error_response(f"unknown op: {op}"))
         return 1