@plannotator/opencode 0.16.4 → 0.16.6

package/dist/index.js

@@ -26667,6 +26667,14 @@ async function gitResetFile(runtime, filePath, cwd) {
   validateFilePath(filePath);
   await ensureGitSuccess(runtime, ["reset", "HEAD", "--", filePath], cwd);
 }
+function parseP4DiffType(diffType) {
+  if (diffType === "p4-default")
+    return { changelist: "default" };
+  if (diffType.startsWith("p4-changelist:")) {
+    return { changelist: diffType.slice("p4-changelist:".length) };
+  }
+  return null;
+}
 
 // ../../packages/server/git.ts
 async function runGit(args, options) {
@@ -26711,6 +26719,369 @@ function gitResetFile2(filePath, cwd) {
   return gitResetFile(runtime, filePath, cwd);
 }
 
+// ../../packages/server/p4.ts
+async function runP4(args, options) {
+  const proc = Bun.spawn(["p4", ...args], {
+    cwd: options?.cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  return { stdout, stderr, exitCode };
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+function toRelativePath(absPath, normalizedRoot) {
+  const normalized = normalizePath(absPath);
+  if (normalized.startsWith(normalizedRoot + "/")) {
+    return normalized.slice(normalizedRoot.length + 1);
+  }
+  if (normalized.startsWith(normalizedRoot)) {
+    return normalized.slice(normalizedRoot.length);
+  }
+  return normalized;
+}
+var workspaceCache = new Map;
+var CACHE_TTL_MS = 30000;
+async function detectP4Workspace(cwd) {
+  const key = cwd ?? process.cwd();
+  const cached = workspaceCache.get(key);
+  if (cached && Date.now() - cached.ts < CACHE_TTL_MS) {
+    return cached.info;
+  }
+  const result = await runP4(["info"], { cwd });
+  if (result.exitCode !== 0) {
+    workspaceCache.set(key, { info: null, ts: Date.now() });
+    return null;
+  }
+  const info = {};
+  for (const line of result.stdout.split(`
+`)) {
+    const colonIdx = line.indexOf(": ");
+    if (colonIdx !== -1) {
+      info[line.slice(0, colonIdx).trim()] = line.slice(colonIdx + 2).trim();
+    }
+  }
+  const clientName = info["Client name"];
+  const clientRoot = info["Client root"];
+  const userName = info["User name"];
+  const serverAddress = info["Server address"];
+  if (!clientName || !clientRoot) {
+    workspaceCache.set(key, { info: null, ts: Date.now() });
+    return null;
+  }
+  const wsInfo = {
+    clientName,
+    clientRoot,
+    normalizedRoot: normalizePath(clientRoot).replace(/\/$/, ""),
+    userName,
+    serverAddress
+  };
+  workspaceCache.set(key, { info: wsInfo, ts: Date.now() });
+  return wsInfo;
+}
+async function getP4Context(cwd) {
+  const workspace = await detectP4Workspace(cwd);
+  if (!workspace) {
+    return {
+      currentBranch: "",
+      defaultBranch: "",
+      diffOptions: [],
+      worktrees: [],
+      cwd,
+      vcsType: "p4"
+    };
+  }
+  const diffOptions = [];
+  const [defaultOpened, changesResult] = await Promise.all([
+    runP4(["opened", "-c", "default"], { cwd }),
+    runP4(["changes", "-s", "pending", "-u", workspace.userName, "-c", workspace.clientName], { cwd })
+  ]);
+  if (defaultOpened.exitCode === 0 && defaultOpened.stdout.trim()) {
+    diffOptions.push({ id: "p4-default", label: "Default changelist" });
+  }
+  if (changesResult.exitCode === 0) {
+    const candidates = [];
+    for (const line of changesResult.stdout.trim().split(`
+`)) {
+      if (!line)
+        continue;
+      const match = line.match(/^Change (\d+) on .+? by .+? \*?'(.*)'\s*$/);
+      if (match) {
+        const desc = match[2].length > 40 ? match[2].slice(0, 40) + "..." : match[2];
+        candidates.push({ clNumber: match[1], desc });
+      }
+    }
+    const checks = await Promise.all(candidates.map(({ clNumber }) => runP4(["opened", "-c", clNumber], { cwd })));
+    for (let i = 0;i < candidates.length; i++) {
+      if (checks[i].exitCode === 0 && checks[i].stdout.trim()) {
+        diffOptions.push({
+          id: `p4-changelist:${candidates[i].clNumber}`,
+          label: `CL ${candidates[i].clNumber}: ${candidates[i].desc}`
+        });
+      }
+    }
+  }
+  return {
+    currentBranch: workspace.clientName,
+    defaultBranch: "",
+    diffOptions,
+    worktrees: [],
+    cwd: cwd ?? workspace.clientRoot,
+    vcsType: "p4"
+  };
+}
+function convertP4DiffToGitFormat(rawOutput, normalizedRoot) {
+  const lines = rawOutput.split(`
+`);
+  const result = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const separatorMatch = line.match(/^==== .+#\d+ - (.+?) ====/);
+    if (separatorMatch) {
+      const relativePath = toRelativePath(separatorMatch[1], normalizedRoot);
+      result.push(`diff --git a/${relativePath} b/${relativePath}`);
+      continue;
+    }
+    if (line.startsWith("--- ") && !line.startsWith("--- a/")) {
+      const nextLine = lines[i + 1];
+      let relativePath;
+      if (nextLine && nextLine.startsWith("+++ ")) {
+        const localPath = nextLine.slice(4).split("\t")[0];
+        relativePath = toRelativePath(localPath, normalizedRoot);
+      } else {
+        const rawPath = line.slice(4).split("\t")[0];
+        relativePath = toRelativePath(rawPath, normalizedRoot);
+      }
+      result.push(`diff --git a/${relativePath} b/${relativePath}`);
+      result.push(`--- a/${relativePath}`);
+      continue;
+    }
+    if (line.startsWith("+++ ") && !line.startsWith("+++ b/")) {
+      const localPath = line.slice(4).split("\t")[0];
+      const relativePath = toRelativePath(localPath, normalizedRoot);
+      result.push(`+++ b/${relativePath}`);
+      continue;
+    }
+    result.push(line);
+  }
+  return result.join(`
+`);
+}
+async function getNewFileDiff(localPath, relativePath) {
+  try {
+    const content = await Bun.file(localPath).text();
+    const lines = content.split(`
+`);
+    const header = [
+      `diff --git a/${relativePath} b/${relativePath}`,
+      "new file mode 100644",
+      "--- /dev/null",
+      `+++ b/${relativePath}`,
+      `@@ -0,0 +1,${lines.length} @@`
+    ];
+    return header.join(`
+`) + `
+` + lines.map((l) => `+${l}`).join(`
+`);
+  } catch {
+    return "";
+  }
+}
+async function batchResolveDepotPaths(depotPaths, normalizedRoot, cwd) {
+  const result = new Map;
+  if (depotPaths.length === 0)
+    return result;
+  const whereResult = await runP4(["where", ...depotPaths], { cwd });
+  if (whereResult.exitCode !== 0)
+    return result;
+  const outputLines = whereResult.stdout.trim().split(`
+`);
+  for (let i = 0;i < outputLines.length && i < depotPaths.length; i++) {
+    const whereOutput = outputLines[i];
+    const rootIdx = whereOutput.indexOf(normalizePath(normalizedRoot).length > 0 ? normalizedRoot : "NOMATCH");
+    const clientRootBackslash = normalizedRoot.replace(/\//g, "\\");
+    const bsIdx = whereOutput.indexOf(clientRootBackslash);
+    const fwIdx = whereOutput.indexOf(normalizedRoot);
+    const idx = bsIdx !== -1 ? bsIdx : fwIdx;
+    if (idx === -1)
+      continue;
+    const localPath = normalizePath(whereOutput.slice(idx));
+    const relativePath = toRelativePath(localPath, normalizedRoot);
+    result.set(depotPaths[i], { localPath, relativePath });
+  }
+  return result;
+}
+async function runP4Diff(diffType, cwd) {
+  const workspace = await detectP4Workspace(cwd);
+  if (!workspace) {
+    return { patch: "", label: "P4 error", error: "Not in a Perforce workspace" };
+  }
+  const parsed = parseP4DiffType(diffType);
+  if (!parsed) {
+    return { patch: "", label: "Unknown diff type" };
+  }
+  try {
+    const label = parsed.changelist === "default" ? "Default changelist" : `Changelist ${parsed.changelist}`;
+    const openedArgs = parsed.changelist === "default" ? ["opened", "-c", "default"] : ["opened", "-c", parsed.changelist];
+    const openedResult = await runP4(openedArgs, { cwd });
+    if (openedResult.exitCode !== 0 || !openedResult.stdout.trim()) {
+      return { patch: "", label, error: openedResult.stderr || undefined };
+    }
+    const diffDepotPaths = [];
+    const addedDepotPaths = [];
+    for (const line of openedResult.stdout.trim().split(`
+`)) {
+      if (!line)
+        continue;
+      const typeMatch = line.match(/\((\S+)\)\s*(by\s|$)/);
+      if (typeMatch && typeMatch[1].startsWith("binary"))
+        continue;
+      const depotPath = line.split("#")[0];
+      if (!depotPath)
+        continue;
+      if (line.includes(" - add ")) {
+        addedDepotPaths.push(depotPath);
+      } else {
+        diffDepotPaths.push(depotPath);
+      }
+    }
+    let patch = "";
+    if (diffDepotPaths.length > 0) {
+      const diffResult = await runP4(["diff", "-du", ...diffDepotPaths], { cwd });
+      if (diffResult.exitCode === 0 || diffResult.stdout.trim()) {
+        patch = convertP4DiffToGitFormat(diffResult.stdout, workspace.normalizedRoot);
+      }
+    }
+    if (addedDepotPaths.length > 0) {
+      const resolved = await batchResolveDepotPaths(addedDepotPaths, workspace.normalizedRoot, cwd);
+      for (const depotPath of addedDepotPaths) {
+        const mapping = resolved.get(depotPath);
+        if (!mapping)
+          continue;
+        const newFilePatch = await getNewFileDiff(mapping.localPath, mapping.relativePath);
+        if (newFilePatch) {
+          patch += (patch ? `
+` : "") + newFilePatch;
+        }
+      }
+    }
+    return { patch, label };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { patch: "", label: "P4 error", error: message };
+  }
+}
+async function getP4FileContentsForDiff(diffType, filePath, cwd) {
+  const workspace = await detectP4Workspace(cwd);
+  if (!workspace)
+    return { oldContent: null, newContent: null };
+  validateFilePath(filePath);
+  const fullLocalPath = `${workspace.normalizedRoot}/${filePath}`;
+  const [printResult, newContent] = await Promise.all([
+    runP4(["print", "-q", `${fullLocalPath}#have`], { cwd }),
+    Bun.file(fullLocalPath).text().catch(() => null)
+  ]);
+  return {
+    oldContent: printResult.exitCode === 0 ? printResult.stdout : null,
+    newContent
+  };
+}
+
+// ../../packages/server/vcs.ts
+var GIT_DIFF_TYPES = new Set(["uncommitted", "staged", "unstaged", "last-commit", "branch"]);
+var gitProvider = {
+  id: "git",
+  async detect(cwd) {
+    const proc = Bun.spawn(["git", "rev-parse", "--is-inside-work-tree"], {
+      cwd: cwd ?? undefined,
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    return await proc.exited === 0;
+  },
+  ownsDiffType(diffType) {
+    return GIT_DIFF_TYPES.has(diffType) || diffType.startsWith("worktree:");
+  },
+  getContext: getGitContext2,
+  runDiff(diffType, defaultBranch, cwd) {
+    return runGitDiff2(diffType, defaultBranch, cwd);
+  },
+  getFileContents(diffType, defaultBranch, filePath, oldPath, cwd) {
+    return getFileContentsForDiff2(diffType, defaultBranch, filePath, oldPath, cwd);
+  },
+  stageFile: gitAddFile2,
+  unstageFile: gitResetFile2,
+  resolveCwd(diffType, fallbackCwd) {
+    if (diffType.startsWith("worktree:")) {
+      const parsed = parseWorktreeDiffType(diffType);
+      if (parsed)
+        return parsed.path;
+    }
+    return fallbackCwd;
+  }
+};
+var p4Provider = {
+  id: "p4",
+  async detect(cwd) {
+    return await detectP4Workspace(cwd) !== null;
+  },
+  ownsDiffType(diffType) {
+    return diffType === "p4-default" || diffType.startsWith("p4-changelist:");
+  },
+  getContext: getP4Context,
+  runDiff(diffType, _defaultBranch, cwd) {
+    return runP4Diff(diffType, cwd);
+  },
+  getFileContents(diffType, _defaultBranch, filePath, _oldPath, cwd) {
+    return getP4FileContentsForDiff(diffType, filePath, cwd);
+  }
+};
+var providers = [gitProvider, p4Provider];
+var vcsCache = new Map;
+function getProviderForDiffType(diffType) {
+  for (const provider of providers) {
+    if (provider.ownsDiffType(diffType))
+      return provider;
+  }
+  return gitProvider;
+}
+async function runVcsDiff(diffType, defaultBranch = "main", cwd) {
+  const provider = getProviderForDiffType(diffType);
+  return provider.runDiff(diffType, defaultBranch, cwd);
+}
+async function getVcsFileContentsForDiff(diffType, defaultBranch, filePath, oldPath, cwd) {
+  const provider = getProviderForDiffType(diffType);
+  return provider.getFileContents(diffType, defaultBranch, filePath, oldPath, cwd);
+}
+function canStageFiles(diffType) {
+  const provider = getProviderForDiffType(diffType);
+  return provider.stageFile !== undefined;
+}
+async function stageFile(diffType, filePath, cwd) {
+  const provider = getProviderForDiffType(diffType);
+  if (!provider.stageFile) {
+    throw new Error(`Staging not available for ${provider.id}`);
+  }
+  return provider.stageFile(filePath, cwd);
+}
+async function unstageFile(diffType, filePath, cwd) {
+  const provider = getProviderForDiffType(diffType);
+  if (!provider.unstageFile) {
+    throw new Error(`Unstaging not available for ${provider.id}`);
+  }
+  return provider.unstageFile(filePath, cwd);
+}
+function resolveVcsCwd(diffType, fallbackCwd) {
+  const provider = getProviderForDiffType(diffType);
+  return provider.resolveCwd?.(diffType, fallbackCwd) ?? fallbackCwd;
+}
+
 // ../../packages/shared/agent-jobs.ts
 var AGENT_HEARTBEAT_COMMENT = `:
 
@@ -27963,12 +28334,7 @@ async function startReviewServer(options) {
     mode: "review",
     getServerUrl: () => serverUrl,
     getCwd: () => {
-      if (currentDiffType.startsWith("worktree:")) {
-        const parsed = parseWorktreeDiffType(currentDiffType);
-        if (parsed)
-          return parsed.path;
-      }
-      return gitContext?.cwd ?? process.cwd();
+      return resolveVcsCwd(currentDiffType, gitContext?.cwd) ?? process.cwd();
     }
   });
   const aiRegistry = new ProviderRegistry;
@@ -28029,12 +28395,7 @@ async function startReviewServer(options) {
       registry: aiRegistry,
       sessionManager: aiSessionManager,
       getCwd: () => {
-        if (currentDiffType.startsWith("worktree:")) {
-          const parsed = parseWorktreeDiffType(currentDiffType);
-          if (parsed)
-            return parsed.path;
-        }
-        return gitContext?.cwd ?? process.cwd();
+        return resolveVcsCwd(currentDiffType, gitContext?.cwd) ?? process.cwd();
       }
     });
   }
@@ -28092,7 +28453,7 @@ async function startReviewServer(options) {
               }
               const defaultBranch = gitContext?.defaultBranch || "main";
               const defaultCwd = gitContext?.cwd;
-              const result = await runGitDiff2(newDiffType, defaultBranch, defaultCwd);
+              const result = await runVcsDiff(newDiffType, defaultBranch, defaultCwd);
               currentPatch = result.patch;
               currentGitRef = result.label;
               currentDiffType = newDiffType;
@@ -28147,35 +28508,27 @@ async function startReviewServer(options) {
             }
             const defaultBranch = gitContext?.defaultBranch || "main";
             const defaultCwd = gitContext?.cwd;
-            const result = await getFileContentsForDiff2(currentDiffType, defaultBranch, filePath, oldPath, defaultCwd);
+            const result = await getVcsFileContentsForDiff(currentDiffType, defaultBranch, filePath, oldPath, defaultCwd);
             return Response.json(result);
           }
           if (url.pathname === "/api/git-add" && req.method === "POST") {
-            if (isPRMode) {
-              return Response.json({ error: "Not available for PR reviews" }, { status: 400 });
+            if (isPRMode || !canStageFiles(currentDiffType)) {
+              return Response.json({ error: "Staging not available" }, { status: 400 });
             }
             try {
               const body = await req.json();
               if (!body.filePath) {
                 return Response.json({ error: "Missing filePath" }, { status: 400 });
               }
-              let cwd;
-              if (currentDiffType.startsWith("worktree:")) {
-                const parsed = parseWorktreeDiffType(currentDiffType);
-                if (parsed)
-                  cwd = parsed.path;
-              }
-              if (!cwd) {
-                cwd = gitContext?.cwd;
-              }
+              const cwd = resolveVcsCwd(currentDiffType, gitContext?.cwd);
               if (body.undo) {
-                await gitResetFile2(body.filePath, cwd);
+                await unstageFile(currentDiffType, body.filePath, cwd);
               } else {
-                await gitAddFile2(body.filePath, cwd);
+                await stageFile(currentDiffType, body.filePath, cwd);
               }
               return Response.json({ ok: true });
             } catch (err) {
-              const message = err instanceof Error ? err.message : "Failed to git add";
+              const message = err instanceof Error ? err.message : "Failed to stage file";
               return Response.json({ error: message }, { status: 500 });
             }
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plannotator/opencode",
-  "version": "0.16.4",
+  "version": "0.16.6",
   "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.16.4",
+    "@plannotator/server": "0.16.6",
     "@plannotator/shared": "0.0.1"
   },
   "peerDependencies": {