@plannotator/opencode 0.19.15 → 0.19.16

package/dist/index.js

@@ -66427,6 +66427,321 @@ ${prompt}` : prompt;
     }
   };
 }
+// ../../packages/shared/code-nav.ts
+function validateFilePath2(filePath) {
+  if (filePath.includes("..") || filePath.startsWith("/")) {
+    throw new Error("Invalid file path");
+  }
+}
+var CODE_NAV_IGNORED_GLOBS = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "__pycache__",
+  ".turbo",
+  ".cache",
+  "target",
+  "vendor",
+  "coverage",
+  ".venv",
+  ".pytest_cache"
+];
+var RG_TYPE_MAP = {
+  typescript: "ts",
+  javascript: "js",
+  python: "py",
+  go: "go",
+  rust: "rust",
+  java: "java",
+  ruby: "ruby",
+  cpp: "cpp",
+  c: "c"
+};
+var DEFINITION_PATTERNS = [
+  {
+    languages: ["typescript", "javascript"],
+    patterns: [
+      String.raw`(?:export\s+)?(?:async\s+)?function\s+SYMBOL\b`,
+      String.raw`(?:export\s+)?(?:const|let|var)\s+SYMBOL\s*[=:]`,
+      String.raw`(?:export\s+)?class\s+SYMBOL\b`,
+      String.raw`(?:export\s+)?(?:interface|type)\s+SYMBOL\b`,
+      String.raw`(?:export\s+)?enum\s+SYMBOL\b`,
+      String.raw`^\s+(?:(?:async|static|readonly|get|set|private|protected|public)\s+)+SYMBOL\s*[(<:]`
+    ]
+  },
+  {
+    languages: ["python"],
+    patterns: [
+      String.raw`(?:^|\s)def\s+SYMBOL\s*\(`,
+      String.raw`(?:^|\s)class\s+SYMBOL\b`,
+      String.raw`^SYMBOL\s*=`
+    ]
+  },
+  {
+    languages: ["go"],
+    patterns: [
+      String.raw`func\s+(?:\([^)]+\)\s+)?SYMBOL\s*\(`,
+      String.raw`type\s+SYMBOL\s`,
+      String.raw`var\s+SYMBOL\s`
+    ]
+  },
+  {
+    languages: ["rust"],
+    patterns: [
+      String.raw`(?:pub(?:\([^)]*\))?\s+)?fn\s+SYMBOL\b`,
+      String.raw`(?:pub(?:\([^)]*\))?\s+)?struct\s+SYMBOL\b`,
+      String.raw`(?:pub(?:\([^)]*\))?\s+)?enum\s+SYMBOL\b`,
+      String.raw`(?:pub(?:\([^)]*\))?\s+)?trait\s+SYMBOL\b`,
+      String.raw`(?:pub(?:\([^)]*\))?\s+)?type\s+SYMBOL\b`,
+      String.raw`(?:pub(?:\([^)]*\))?\s+)?mod\s+SYMBOL\b`
+    ]
+  }
+];
+var GENERIC_DEFINITION_PATTERNS = [
+  String.raw`(?:function|def|func|fn|class|struct|enum|trait|interface|type)\s+SYMBOL\b`,
+  String.raw`(?:const|let|var|val)\s+SYMBOL\s*[=:]`
+];
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function sameDirectory(a2, b3) {
+  const dirA = a2.lastIndexOf("/");
+  const dirB = b3.lastIndexOf("/");
+  if (dirA === -1 && dirB === -1)
+    return true;
+  return a2.slice(0, dirA) === b3.slice(0, dirB);
+}
+function isTestFile(filePath) {
+  return /(?:test|spec|__tests__|_test\.|\.test\.|\.spec\.)/i.test(filePath);
+}
+function buildRgArgs(symbol, language) {
+  const args = [
+    "--json",
+    "--line-number",
+    "--column",
+    "--max-count",
+    "50",
+    "--max-filesize",
+    "1M",
+    "--no-messages"
+  ];
+  for (const dir of CODE_NAV_IGNORED_GLOBS) {
+    args.push("--glob", `!${dir}`);
+  }
+  if (language) {
+    const rgType = RG_TYPE_MAP[language];
+    if (rgType)
+      args.push("--type", rgType);
+  }
+  args.push("--word-regexp", "--", escapeRegex(symbol), ".");
+  return args;
+}
+var PARSE_CAP = 500;
+function parseRgJsonOutput(stdout, symbol, language) {
+  const locations = [];
+  const lines = stdout.split(`
+`);
+  for (const line of lines) {
+    if (locations.length >= PARSE_CAP)
+      break;
+    if (!line.trim())
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (parsed.type !== "match")
+      continue;
+    const d2 = parsed.data;
+    const snippet = d2.lines.text.trimEnd();
+    const column = d2.submatches?.[0]?.start ?? 0;
+    const kind = classifyMatch(snippet, symbol, language);
+    const filePath = d2.path.text.startsWith("./") ? d2.path.text.slice(2) : d2.path.text;
+    locations.push({
+      kind,
+      confidence: kind === "definition" ? "likely" : "possible",
+      filePath,
+      line: d2.line_number,
+      column,
+      snippet: snippet.length > 200 ? snippet.slice(0, 200) + "\u2026" : snippet
+    });
+  }
+  return locations;
+}
+function classifyMatch(snippet, symbol, language) {
+  const escaped = escapeRegex(symbol);
+  if (language) {
+    const langPatterns = DEFINITION_PATTERNS.find((p2) => p2.languages.includes(language));
+    if (langPatterns) {
+      for (const pattern of langPatterns.patterns) {
+        const re3 = new RegExp(pattern.replace("SYMBOL", escaped));
+        if (re3.test(snippet))
+          return "definition";
+      }
+    }
+  }
+  for (const pattern of GENERIC_DEFINITION_PATTERNS) {
+    const re3 = new RegExp(pattern.replace("SYMBOL", escaped));
+    if (re3.test(snippet))
+      return "definition";
+  }
+  return "reference";
+}
+function rankLocations(locations, context, cap2 = 50) {
+  const capped = locations.length > cap2;
+  const changedSet = new Set(context.changedFiles);
+  function score(loc) {
+    let s2 = 0;
+    if (loc.filePath === context.sourceFilePath)
+      s2 += 1000;
+    else if (changedSet.has(loc.filePath))
+      s2 += 500;
+    else if (sameDirectory(loc.filePath, context.sourceFilePath))
+      s2 += 200;
+    if (isTestFile(loc.filePath) && !context.isTestFile)
+      s2 -= 300;
+    if (loc.kind === "definition")
+      s2 += 100;
+    if (loc.confidence === "likely")
+      s2 += 50;
+    return s2;
+  }
+  const sorted = [...locations].sort((a2, b3) => score(b3) - score(a2));
+  const truncated = sorted.slice(0, cap2);
+  return {
+    definitions: truncated.filter((l3) => l3.kind === "definition"),
+    references: truncated.filter((l3) => l3.kind === "reference"),
+    capped
+  };
+}
+function extractChangedFiles(patch) {
+  if (!patch)
+    return [];
+  const set = new Set;
+  const re3 = /^diff --git a\/(.+?) b\/(.+)$/gm;
+  let m3;
+  while ((m3 = re3.exec(patch)) !== null) {
+    set.add(m3[1]);
+    set.add(m3[2]);
+  }
+  return [...set];
+}
+function validateCodeNavRequest(body3) {
+  if (!body3 || typeof body3 !== "object")
+    return "Invalid request body";
+  const b3 = body3;
+  if (typeof b3.symbol !== "string" || !b3.symbol.trim()) {
+    return "Missing or empty symbol";
+  }
+  if (typeof b3.filePath !== "string" || !b3.filePath.trim()) {
+    return "Missing filePath";
+  }
+  try {
+    validateFilePath2(b3.filePath);
+  } catch {
+    return "Invalid filePath";
+  }
+  if (b3.side !== "old" && b3.side !== "new") {
+    return "side must be 'old' or 'new'";
+  }
+  return null;
+}
+var rgAvailable = null;
+async function resolveCodeNav(runtime4, request, cwd, changedFiles) {
+  const start = Date.now();
+  if (rgAvailable === null) {
+    const check = await runtime4.runCommand("rg", ["--version"], {
+      cwd,
+      timeoutMs: 2000
+    });
+    rgAvailable = check.exitCode === 0;
+  }
+  if (!rgAvailable) {
+    return {
+      backend: "unavailable",
+      complete: true,
+      definitions: [],
+      references: [],
+      searchScope: "head",
+      stats: { elapsedMs: Date.now() - start, capped: false }
+    };
+  }
+  const args = buildRgArgs(request.symbol, request.language);
+  const result = await runtime4.runCommand("rg", args, {
+    cwd,
+    timeoutMs: 5000
+  });
+  if (result.exitCode === 2) {
+    return {
+      backend: "search",
+      complete: true,
+      definitions: [],
+      references: [],
+      searchScope: "head",
+      stats: { elapsedMs: Date.now() - start, capped: false }
+    };
+  }
+  const locations = parseRgJsonOutput(result.stdout, request.symbol, request.language);
+  const ranked = rankLocations(locations, {
+    sourceFilePath: request.filePath,
+    changedFiles,
+    isTestFile: isTestFile(request.filePath)
+  });
+  return {
+    backend: "search",
+    complete: true,
+    definitions: ranked.definitions,
+    references: ranked.references,
+    searchScope: "head",
+    stats: { elapsedMs: Date.now() - start, capped: ranked.capped }
+  };
+}
+
+// ../../packages/server/code-nav.ts
+var bunCodeNavRuntime = {
+  async runCommand(command, args, options) {
+    let proc;
+    try {
+      proc = Bun.spawn([command, ...args], {
+        cwd: options?.cwd,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+    } catch {
+      return { stdout: "", stderr: "command not found", exitCode: 1 };
+    }
+    let timer;
+    if (options?.timeoutMs) {
+      timer = setTimeout(() => proc.kill(), options.timeoutMs);
+    }
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    if (timer)
+      clearTimeout(timer);
+    return { stdout, stderr, exitCode };
+  }
+};
+async function handleCodeNavResolve(req, cwd, changedFiles) {
+  try {
+    const body3 = await req.json();
+    const error = validateCodeNavRequest(body3);
+    if (error) {
+      return Response.json({ error }, { status: 400 });
+    }
+    const result = await resolveCodeNav(bunCodeNavRuntime, body3, cwd, changedFiles);
+    return Response.json(result);
+  } catch (err) {
+    return Response.json({ error: err instanceof Error ? err.message : "Code navigation failed" }, { status: 500 });
+  }
+}
+
 // ../../packages/server/review.ts
 var MAX_RETRIES2 = 5;
 var RETRY_DELAY_MS2 = 500;
@@ -66986,6 +67301,37 @@ async function startReviewServer(options) {
             }
             return Response.json({ error: "No file access available" }, { status: 400 });
           }
+          if (url.pathname === "/api/code-nav/resolve" && req.method === "POST") {
+            const hasCodeNavAccess = !!gitContext || !!options.agentCwd || !!options.worktreePool;
+            if (!hasCodeNavAccess) {
+              return Response.json({ error: "Code navigation requires local access" }, { status: 400 });
+            }
+            const navCwd = resolveAgentCwd();
+            const changedFiles = extractChangedFiles(currentPatch);
+            return handleCodeNavResolve(req, navCwd, changedFiles);
+          }
+          if (url.pathname === "/api/code-nav/file" && req.method === "GET") {
+            const hasCodeNavAccess = !!gitContext || !!options.agentCwd || !!options.worktreePool;
+            if (!hasCodeNavAccess) {
+              return Response.json({ error: "Code navigation requires local access" }, { status: 400 });
+            }
+            const filePath = url.searchParams.get("path");
+            if (!filePath) {
+              return Response.json({ error: "Missing path" }, { status: 400 });
+            }
+            try {
+              validateFilePath(filePath);
+            } catch {
+              return Response.json({ error: "Invalid path" }, { status: 400 });
+            }
+            try {
+              const navCwd = resolveAgentCwd();
+              const content = await Bun.file(`${navCwd}/${filePath}`).text();
+              return Response.json({ content });
+            } catch {
+              return Response.json({ error: "File not found" }, { status: 404 });
+            }
+          }
           if (url.pathname === "/api/git-add" && req.method === "POST") {
             const stageCwd = resolveVcsCwd(currentDiffType, gitContext?.cwd);
             if (isPRMode || !await canStageFiles(currentDiffType, stageCwd)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plannotator/opencode",
-  "version": "0.19.15",
+  "version": "0.19.16",
   "description": "Plannotator plugin for OpenCode - interactive plan review with visual annotation",
   "author": "backnotprop",
   "license": "MIT OR Apache-2.0",
@@ -38,7 +38,7 @@
     "@opencode-ai/plugin": "^1.1.10"
   },
   "devDependencies": {
-    "@plannotator/server": "0.19.15",
+    "@plannotator/server": "0.19.16",
     "@plannotator/shared": "0.0.1"
   },
   "peerDependencies": {