@plannotator/opencode 0.19.17 → 0.19.18

package/dist/index.js

@@ -45044,7 +45044,7 @@ var init_opencode_sdk = __esm(() => {
 
 // index.ts
 import { tool } from "@opencode-ai/plugin";
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 import path4 from "path";
 
 // ../../packages/server/remote.ts
@@ -67743,13 +67743,6 @@ var PLAN_TOOL_NAMES = {
 function getPlanToolName(runtime4) {
   return runtime4 && PLAN_TOOL_NAMES[runtime4] || "ExitPlanMode";
 }
-function buildPlanFileRule(toolName, planFilePath) {
-  if (!planFilePath)
-    return "";
-  return `- Your plan is saved at: ${planFilePath}
-  You can edit this file to make targeted changes, then pass its path to ${toolName}.
-`;
-}
 var DEFAULT_REVIEW_APPROVED_PROMPT = `# Code Review
 
 Code review completed \u2014 no changes requested.`;
@@ -68762,21 +68755,63 @@ function getReviewHtml() {
   return _reviewHtml;
 }
 var DEFAULT_PLAN_TIMEOUT_SECONDS = 345600;
-function isFilePath(value) {
-  return path4.isAbsolute(value) && value.endsWith(".md") && existsSync10(value);
+var MAX_PLAN_SIZE = 5 * 1024 * 1024;
+function getPlanBackingPath(directory) {
+  const planDir = path4.join(directory, ".opencode", "plans");
+  return path4.join(planDir, "_active-plan.md");
+}
+function applyEdits(existingLines, edits) {
+  const sorted = [...edits].sort((a3, b3) => a3.start - b3.start);
+  const lines = [...existingLines];
+  let offset = 0;
+  for (const edit of sorted) {
+    const start = edit.start - 1 + offset;
+    const end = edit.end != null ? edit.end + offset : lines.length;
+    const newLines = edit.content ? edit.content.split(`
+`) : [];
+    const removedCount = end - start;
+    lines.splice(start, removedCount, ...newLines);
+    offset += newLines.length - removedCount;
+  }
+  return lines;
 }
-function resolvePlanContent(plan) {
-  if (isFilePath(plan)) {
-    const content = readFileSync7(plan, "utf-8");
-    if (!content.trim()) {
-      throw new Error(`Plan file at ${plan} is empty. Write your plan content first, then call submit_plan.`);
+function validateEdits(existingLines, edits) {
+  const lineCount = existingLines.length;
+  for (const edit of edits) {
+    if (!Number.isInteger(edit.start) || edit.start < 1) {
+      return `start must be a positive integer >= 1, got ${edit.start}`;
+    }
+    if (edit.start > lineCount + 1) {
+      return `start (${edit.start}) exceeds file length + 1 (${lineCount + 1})`;
+    }
+    if (edit.end != null) {
+      if (!Number.isInteger(edit.end) || edit.end < edit.start) {
+        return `end (${edit.end}) must be >= start (${edit.start})`;
+      }
+      if (edit.end > lineCount) {
+        return `end (${edit.end}) exceeds file length (${lineCount})`;
+      }
     }
-    return { content, filePath: plan };
   }
-  if (path4.isAbsolute(plan) && plan.endsWith(".md")) {
-    throw new Error(`File not found: ${plan}. Check the path and try again.`);
+  const sorted = [...edits].sort((a3, b3) => a3.start - b3.start);
+  for (let i4 = 1;i4 < sorted.length; i4++) {
+    const prev = sorted[i4 - 1];
+    const curr = sorted[i4];
+    if (prev.start > lineCount)
+      continue;
+    const prevEnd = prev.end ?? lineCount;
+    if (curr.start <= prevEnd) {
+      return `edits overlap: [${prev.start},${prevEnd}] and [${curr.start},${curr.end ?? "end"}]`;
+    }
   }
-  return { content: plan };
+  return null;
+}
+function formatWithLineNumbers(content) {
+  const lines = content.split(`
+`);
+  const width = String(lines.length).length;
+  return lines.map((line, i4) => `${String(i4 + 1).padStart(width)}| ${line}`).join(`
+`);
 }
 function getPlanningPrompt() {
   return `## Plannotator \u2014 Plan Review
@@ -68785,10 +68820,26 @@ You have a plan submission tool called \`submit_plan\`. It opens an interactive
 
 **How to use it:**
 
-- Pass your plan as markdown text \u2014 \`submit_plan(plan: "# My Plan\\n...")\`.
-- Or pass an absolute file path to a .md file \u2014 \`submit_plan(plan: "/path/to/plan.md")\`.
+\`submit_plan\` accepts an array of line-range edits. On first submission, pass the full plan as a single edit starting at line 1:
+
+\`\`\`json
+{ "edits": [{ "start": 1, "content": "# My Plan\\n\\n## Goals\\n..." }] }
+\`\`\`
+
+If the user denies and requests changes, apply surgical edits using line ranges. The tool response includes your plan with line numbers so you can target specific ranges:
+
+\`\`\`json
+{ "edits": [
+  { "start": 12, "end": 14, "content": "revised section content" },
+  { "start": 30, "end": 30, "content": "" }
+] }
+\`\`\`
 
-The tool auto-detects whether you passed text or a file path. Both open the same review UI.
+Edit semantics:
+- \`start\` and \`end\` are 1-indexed, inclusive line numbers
+- Omit \`end\` to replace from \`start\` through end of file (use this for the initial full write)
+- Empty \`content\` with \`start\`/\`end\` deletes those lines
+- Multiple edits in one call are applied in order; line numbers refer to the state before edits
 
 ### Before you write a plan
 
@@ -68956,9 +69007,9 @@ tools (except writing markdown files), or otherwise make changes to the system.
         return;
       output.system.push(`## Plan Submission
 
-When you have completed your plan, call the \`submit_plan\` tool to submit it for user review. Pass your plan as markdown text, or pass an absolute file path to a .md file.
+When you have completed your plan, call the \`submit_plan\` tool to submit it for user review. Pass your full plan as a single edit: \`{ "edits": [{ "start": 1, "content": "..." }] }\`.
 
-The user will review your plan in a visual UI where they can annotate, approve, or request changes. If rejected, revise based on their feedback and call submit_plan again.
+The user will review your plan in a visual UI where they can annotate, approve, or request changes. If rejected, the response includes your plan with line numbers; use targeted edits to revise specific sections.
 
 Do NOT proceed with implementation until your plan is approved.`);
     },
@@ -69007,9 +69058,13 @@ Do NOT proceed with implementation until your plan is approved.`);
   if (shouldRegisterSubmitPlan(workflowOptions)) {
     plugin.tool = {
       submit_plan: tool({
-        description: "Planning tool used to submit a plan to the user for review. Before calling this tool you must conduct interactive and exploratory analysis in order to submit a quality plan. Ask questions. Explore the codebase for context if needed. Only call submit_plan once you have enough details to create a quality plan. Work with the user to get those details. Pass either markdown text or an absolute path to a .md file.",
+        description: "Submit a plan for user review via line-range edits. First call: pass a single edit with start=1 and your full plan as content (omit end). Subsequent calls after denial: pass targeted edits using the line numbers from the previous response. The tool manages a backing file; you never touch the file directly.",
         args: {
-          plan: tool.schema.string().describe("The plan \u2014 either markdown text or an absolute path to a .md file on disk.")
+          edits: tool.schema.array(tool.schema.object({
+            start: tool.schema.number().describe("1-indexed start line (inclusive)"),
+            end: tool.schema.number().optional().describe("1-indexed end line (inclusive). Omit to replace from start through end of file."),
+            content: tool.schema.string().describe("Replacement content. Empty string deletes the line range.")
+          })).describe("Array of line-range edits to apply to the plan.")
         },
         async execute(args, context) {
           const invokingAgent = context.agent;
@@ -69018,18 +69073,37 @@ Do NOT proceed with implementation until your plan is approved.`);
 
 Use /plannotator-last or /plannotator-annotate for manual review, or set workflow to all-agents to allow broader submit_plan access.`;
           }
-          let planContent;
-          let sourceFilePath;
+          if (!args.edits || args.edits.length === 0) {
+            return "Error: No edits provided. Pass at least one edit with start and content.";
+          }
+          const backingPath = getPlanBackingPath(ctx.directory);
+          const backingDir = path4.dirname(backingPath);
+          mkdirSync8(backingDir, { recursive: true });
+          let existingContent = "";
+          if (existsSync10(backingPath)) {
+            existingContent = readFileSync7(backingPath, "utf-8");
+          }
+          const existingLines = existingContent ? existingContent.split(`
+`) : [];
+          const validationError = validateEdits(existingLines, args.edits);
+          if (validationError) {
+            return `Error: ${validationError}`;
+          }
+          let resultLines;
           try {
-            const resolved = resolvePlanContent(args.plan);
-            planContent = resolved.content;
-            sourceFilePath = resolved.filePath;
+            resultLines = applyEdits(existingLines, args.edits);
           } catch (err) {
-            return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            return `Error applying edits: ${err instanceof Error ? err.message : String(err)}`;
+          }
+          const planContent = resultLines.join(`
+`);
+          if (planContent.length > MAX_PLAN_SIZE) {
+            return `Error: Plan content exceeds the maximum size of ${MAX_PLAN_SIZE / (1024 * 1024)}MB.`;
           }
           if (!planContent.trim()) {
-            return "Error: Plan content is empty. Write your plan first, then call submit_plan.";
+            return "Error: Plan content is empty after applying edits.";
           }
+          writeFileSync5(backingPath, planContent, "utf-8");
           const sharingEnabled = await getSharingEnabled();
           const server2 = await startPlannotatorServer({
             plan: planContent,
@@ -69077,7 +69151,7 @@ Use /plannotator-last or /plannotator-annotate for manual review, or set workflo
             }
             if (result.feedback) {
               return getPlanApprovedWithNotesPrompt("opencode", undefined, {
-                planFilePath: sourceFilePath,
+                planFilePath: backingPath,
                 doneMsg: result.savedPath ? `Saved to: ${result.savedPath}` : "",
                 feedback: result.feedback,
                 proceedSuffix: shouldSwitchAgent ? `
@@ -69086,15 +69160,28 @@ Proceed with implementation, incorporating these notes where applicable.` : ""
               });
             }
             return getPlanApprovedPrompt("opencode", undefined, {
-              planFilePath: sourceFilePath,
+              planFilePath: backingPath,
               doneMsg: result.savedPath ? ` Saved to: ${result.savedPath}` : ""
             });
           } else {
+            const lineNumberedPlan = formatWithLineNumbers(planContent);
+            const totalLines = planContent.split(`
+`).length;
             return getPlanDeniedPrompt("opencode", undefined, {
               toolName: getPlanToolName("opencode"),
-              planFileRule: buildPlanFileRule(getPlanToolName("opencode"), sourceFilePath),
+              planFileRule: "",
               feedback: result.feedback || "Plan changes requested"
-            }) + "\n\nAfter making your revisions, call `submit_plan` again to resubmit for review.";
+            }) + `
+
+## Current Plan (${totalLines} lines)
+
+The plan below shows the current state with line numbers. Use these exact line numbers in your next \`submit_plan\` call:
+
+\`\`\`
+${lineNumberedPlan}
+\`\`\`
+
+Call \`submit_plan\` with targeted edits to address the feedback above.`;
           }
         }
       })
@@ -69104,6 +69191,10 @@ Proceed with implementation, incorporating these notes where applicable.` : ""
 };
 var opencode_plugin_default = PlannotatorPlugin;
 export {
+  validateEdits,
+  getPlanBackingPath,
+  formatWithLineNumbers,
   opencode_plugin_default as default,
+  applyEdits,
   PlannotatorPlugin
 };

package/package.json

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