pudu-ai 0.2.18 → 0.2.21

package/dist/cli/repo-cli-4GSG5MD3.js

@@ -0,0 +1,255 @@
+import {
+  na,
+  t
+} from "./chunk-QGEXKMQ5.js";
+import {
+  commandExists,
+  runCommand
+} from "./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";
+var metricOriginSchema = z.enum(["MEASURED", "ESTIMATED", "DERIVED"]);
+var searchIntentSchema = z.enum([
+  "TEXT",
+  "STRUCTURAL",
+  "RELATIONSHIP",
+  "IMPACT",
+  "SEMANTIC",
+  "UNKNOWN"
+]);
+var toolAvailabilitySchema = z.object({
+  available: z.boolean(),
+  path: z.string().nullable(),
+  version: z.string().nullable()
+});
+var searchMatchSchema = z.object({
+  file: z.string(),
+  line: z.number().nullable(),
+  column: z.number().nullable(),
+  endLine: z.number().nullable(),
+  endColumn: z.number().nullable(),
+  text: z.string(),
+  strategy: z.enum(["rg", "ast-grep"]),
+  language: z.string().nullable(),
+  metavariables: z.record(z.string())
+});
+var searchResultSchema = z.object({
+  schemaVersion: z.literal(1),
+  ok: z.boolean(),
+  op: z.literal("search"),
+  repo: z.string(),
+  query: z.string().nullable(),
+  structuralPattern: z.string().nullable(),
+  intent: searchIntentSchema,
+  strategy: z.enum(["rg", "ast-grep", "graph", "hybrid"]),
+  matches: z.array(searchMatchSchema),
+  tools: z.object({
+    rg: toolAvailabilitySchema,
+    astGrep: toolAvailabilitySchema,
+    graph: toolAvailabilitySchema
+  }),
+  errors: z.array(
+    z.object({
+      tool: z.string(),
+      message: z.string(),
+      origin: metricOriginSchema
+    })
+  ),
+  metrics: z.object({
+    durationMs: z.number(),
+    matchCount: z.number(),
+    rgQueries: z.number(),
+    astQueries: z.number(),
+    graphQueries: z.number(),
+    origin: metricOriginSchema
+  }),
+  unavailable: z.array(z.string())
+});
+function parseSearchResult(value) {
+  return searchResultSchema.parse(value);
+}
+
+// src/agent-lab/search.ts
+async function searchRepo(request) {
+  const invoked = await invokePuduAgent({
+    op: "search",
+    repo: request.repo,
+    query: request.query ?? null,
+    structuralPattern: request.structuralPattern ?? null,
+    intent: request.intent ?? null,
+    globs: request.globs ?? [],
+    limit: request.limit ?? 100,
+    timeoutMs: request.timeoutMs ?? 2e4
+  });
+  if (invoked.timedOut) {
+    throw new Error("Python search engine timed out");
+  }
+  let parsed;
+  try {
+    parsed = parseJsonStdout(invoked.stdout);
+  } catch {
+    const err = invoked.stderr.trim() || invoked.stdout.trim() || "invalid JSON from python -m pudu_agent";
+    throw new Error(err);
+  }
+  if (typeof parsed === "object" && parsed && "op" in parsed && parsed.op !== "search") {
+    throw new Error(parsed.error ?? "unexpected Python response");
+  }
+  return parseSearchResult(parsed);
+}
+
+// src/agent-lab/repo-cli.ts
+var INTENTS = ["TEXT", "STRUCTURAL", "RELATIONSHIP", "IMPACT", "SEMANTIC", "UNKNOWN"];
+function print(value, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${typeof value === "string" ? value : JSON.stringify(value, null, 2)}
+`);
+}
+function asIntent(raw) {
+  if (!raw) return void 0;
+  const value = raw.trim().toUpperCase();
+  return INTENTS.find((item) => item === value);
+}
+function formatSearchText(result) {
+  const lines = [
+    t("repoSearchTitle"),
+    "",
+    t("aboutRepoSearch"),
+    "",
+    `Intent     ${result.intent}`,
+    `Strategy   ${result.strategy}`,
+    `Repo       ${result.repo}`,
+    `Matches    ${result.metrics.matchCount}  (${result.metrics.origin})`,
+    `Duration   ${result.metrics.durationMs} ms  (${result.metrics.origin})`,
+    `rg         ${result.tools.rg.available ? na(result.tools.rg.version) : t("repoToolMissing", { tool: "rg" })}`,
+    `ast-grep   ${result.tools.astGrep.available ? na(result.tools.astGrep.version) : t("repoToolMissing", { tool: "ast-grep" })}`
+  ];
+  if (result.unavailable.length) {
+    lines.push(`Unavailable ${result.unavailable.join(", ")}`);
+  }
+  for (const err of result.errors) {
+    lines.push(`Error      ${err.tool}: ${err.message}  (${err.origin})`);
+  }
+  lines.push("");
+  if (!result.matches.length) {
+    lines.push(t("repoNoMatches"));
+    return lines.join("\n");
+  }
+  for (const match of result.matches) {
+    const loc = `${match.file}:${na(match.line)}`;
+    const snippet = match.text.replace(/\s+/g, " ").slice(0, 160);
+    lines.push(`${loc}  [${match.strategy}]  ${snippet}`);
+  }
+  return lines.join("\n");
+}
+async function runRepoCommand(args) {
+  const sub = args.positional[0];
+  if (!sub || sub === "help") {
+    print(t("repoHelp"), args.json);
+    return 0;
+  }
+  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;
+  }
+  const queryParts = args.positional.slice(1);
+  const query = queryParts.join(" ").trim() || void 0;
+  if (!query && !args.structural) {
+    process.stderr.write(`${t("repoNeedQuery")}
+`);
+    return 1;
+  }
+  const intent = asIntent(args.intent);
+  const repo = path2.resolve(args.repo ?? process.cwd());
+  try {
+    const result = await searchRepo({
+      repo,
+      query,
+      structuralPattern: args.structural,
+      intent,
+      globs: args.globs,
+      limit: args.limit
+    });
+    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 1;
+  }
+}
+export {
+  formatSearchText,
+  runRepoCommand
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pudu-ai",
-  "version": "0.2.18",
+  "version": "0.2.21",
   "description": "Pudu-AI — local AI hardware & benchmark lab for the terminal",
   "keywords": [
     "ai",
@@ -32,6 +32,7 @@
   "files": [
     "dist",
     "bin",
+    "python",
     "README.md",
     "LICENSE"
   ],
@@ -39,7 +40,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "npx --yes esbuild src/cli/index.ts --bundle --platform=node --format=esm --outfile=dist/cli/index.js --packages=external --jsx=automatic && node scripts/add-shebang.mjs",
+    "build": "rm -rf dist && npx --yes esbuild src/cli/index.ts --bundle --platform=node --format=esm --splitting --outdir=dist/cli --outbase=src/cli --packages=external --jsx=automatic && node scripts/add-shebang.mjs",
     "dev": "tsx src/cli/index.ts",
     "pudu-ai": "tsx src/cli/index.ts",
     "start": "node dist/cli/index.js",

package/python/pudu_agent/__init__.py

@@ -0,0 +1 @@
+PROTOCOL_VERSION = 1

package/python/pudu_agent/__main__.py

@@ -0,0 +1,4 @@
+from pudu_agent.search import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/python/pudu_agent/ast_search.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+def _which() -> str | None:
+    return shutil.which("ast-grep") or shutil.which("sg")
+
+
+def _version(binary: str) -> str | None:
+    try:
+        proc = subprocess.run(
+            [binary, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    line = (proc.stdout or proc.stderr or "").strip().splitlines()
+    return line[0] if line else None
+
+
+def tool_info() -> dict[str, Any]:
+    path = _which()
+    return {
+        "available": path is not None,
+        "path": path,
+        "version": _version(path) if path else None,
+    }
+
+
+def _match_from_ast(obj: dict[str, Any]) -> dict[str, Any] | None:
+    if not isinstance(obj, dict):
+        return None
+    file_path = obj.get("file")
+    text = obj.get("text")
+    if not isinstance(file_path, str):
+        return None
+    if not isinstance(text, str):
+        text = obj.get("lines") if isinstance(obj.get("lines"), str) else ""
+    rng = obj.get("range") or {}
+    start = rng.get("start") or {}
+    end = rng.get("end") or {}
+    start_line = start.get("line")
+    start_col = start.get("column")
+    end_line = end.get("line")
+    end_col = end.get("column")
+    metavars: dict[str, str] = {}
+    meta = obj.get("metaVariables") or {}
+    single = meta.get("single") if isinstance(meta, dict) else {}
+    if isinstance(single, dict):
+        for key, value in single.items():
+            if isinstance(value, dict) and isinstance(value.get("text"), str):
+                metavars[str(key)] = value["text"]
+    language = obj.get("language")
+    return {
+        "file": file_path,
+        "line": start_line + 1 if isinstance(start_line, int) else None,
+        "column": start_col + 1 if isinstance(start_col, int) else None,
+        "endLine": end_line + 1 if isinstance(end_line, int) else None,
+        "endColumn": end_col + 1 if isinstance(end_col, int) else None,
+        "text": text.rstrip("\n") if isinstance(text, str) else "",
+        "strategy": "ast-grep",
+        "language": language if isinstance(language, str) else None,
+        "metavariables": metavars,
+    }
+
+
+def parse_ast_grep_stdout(stdout: str) -> list[dict[str, Any]]:
+    text = (stdout or "").strip()
+    if not text:
+        return []
+    matches: list[dict[str, Any]] = []
+    try:
+        parsed = json.loads(text)
+        if isinstance(parsed, list):
+            for item in parsed:
+                match = _match_from_ast(item) if isinstance(item, dict) else None
+                if match:
+                    matches.append(match)
+            return matches
+        if isinstance(parsed, dict):
+            match = _match_from_ast(parsed)
+            return [match] if match else []
+    except ValueError:
+        pass
+    for line in text.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            obj = json.loads(line)
+        except ValueError:
+            continue
+        match = _match_from_ast(obj) if isinstance(obj, dict) else None
+        if match:
+            matches.append(match)
+    return matches
+
+
+def run_ast_grep(
+    repo: Path,
+    pattern: str,
+    globs: list[str],
+    limit: int,
+    timeout_s: float,
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    binary = _which()
+    if not binary:
+        return [], [{"tool": "ast-grep", "message": "ast-grep not found on PATH", "origin": "MEASURED"}]
+    args = [binary, "run", "-p", pattern, "--json=stream", str(repo)]
+    for glob in globs:
+        args.extend(["--globs", glob])
+    try:
+        proc = subprocess.run(
+            args,
+            capture_output=True,
+            text=True,
+            timeout=timeout_s,
+            check=False,
+        )
+    except subprocess.TimeoutExpired:
+        return [], [{"tool": "ast-grep", "message": "ast-grep timed out", "origin": "MEASURED"}]
+    except OSError as exc:
+        return [], [{"tool": "ast-grep", "message": str(exc), "origin": "MEASURED"}]
+
+    stdout = proc.stdout or ""
+    if proc.returncode not in (0, 1) and not stdout.strip():
+        retry = [binary, "run", "-p", pattern, "--json", str(repo)]
+        try:
+            proc = subprocess.run(
+                retry,
+                capture_output=True,
+                text=True,
+                timeout=timeout_s,
+                check=False,
+            )
+            stdout = proc.stdout or ""
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            return [], [{"tool": "ast-grep", "message": str(exc), "origin": "MEASURED"}]
+
+    matches = parse_ast_grep_stdout(stdout)[:limit]
+    errors: list[dict[str, Any]] = []
+    if proc.returncode not in (0, 1) and not matches:
+        err = (proc.stderr or "").strip() or f"ast-grep exit {proc.returncode}"
+        errors.append({"tool": "ast-grep", "message": err, "origin": "MEASURED"})
+    return matches, errors

package/python/pudu_agent/protocol.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+PROTOCOL_VERSION = 1
+
+INTENTS = ("TEXT", "STRUCTURAL", "RELATIONSHIP", "IMPACT", "SEMANTIC", "UNKNOWN")
+
+IMPACT_HINTS = (
+    "impact of",
+    "what breaks",
+    "if i change",
+    "if i modify",
+    "affected tests",
+    "what can break",
+)
+RELATIONSHIP_HINTS = (
+    "who calls",
+    "callers of",
+    "depends on",
+    "dependencies of",
+    "path between",
+    "connected to",
+    "imports of",
+    "what depends",
+)
+SEMANTIC_HINTS = ("similar to", "like this code", "meaning of")
+
+
+def read_request(raw: str | None = None) -> dict[str, Any]:
+    text = sys.stdin.read() if raw is None else raw
+    text = text.strip()
+    if not text:
+        raise ValueError("empty request")
+    data = json.loads(text)
+    if not isinstance(data, dict):
+        raise ValueError("request must be a JSON object")
+    return data
+
+
+def write_response(payload: dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(payload, ensure_ascii=False))
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+
+def error_response(message: str, **extra: Any) -> dict[str, Any]:
+    body: dict[str, Any] = {
+        "schemaVersion": PROTOCOL_VERSION,
+        "ok": False,
+        "error": message,
+    }
+    body.update(extra)
+    return body
+
+
+def classify_intent(
+    query: str | None,
+    structural_pattern: str | None,
+    explicit: str | None,
+) -> str:
+    if explicit:
+        value = explicit.strip().upper()
+        if value in INTENTS and value != "UNKNOWN":
+            return value
+    if structural_pattern:
+        return "STRUCTURAL"
+    q = (query or "").strip()
+    if any(token in q for token in ("$$$", "$")):
+        return "STRUCTURAL"
+    low = q.lower()
+    if any(hint in low for hint in IMPACT_HINTS):
+        return "IMPACT"
+    if any(hint in low for hint in RELATIONSHIP_HINTS):
+        return "RELATIONSHIP"
+    if any(hint in low for hint in SEMANTIC_HINTS):
+        return "SEMANTIC"
+    if explicit and explicit.strip().upper() == "UNKNOWN":
+        return "UNKNOWN"
+    if q:
+        return "TEXT"
+    return "UNKNOWN"
+
+
+def strategies_for(intent: str) -> list[str]:
+    if intent == "TEXT":
+        return ["rg"]
+    if intent == "STRUCTURAL":
+        return ["ast-grep"]
+    if intent in {"RELATIONSHIP", "IMPACT"}:
+        return ["graph"]
+    if intent == "SEMANTIC":
+        return []
+    return ["rg", "ast-grep"]