opencode-planpilot 0.1.0 → 0.1.2

package/docs/planpilot.md

@@ -42,6 +42,7 @@ A CLI binary named `planpilot` is available for manual use. If you use the CLI d
 
 ## AI Workflow Guidelines
 - Use Planpilot for all planning, status, and progress tracking; do not use built-in plan/todo tools or other methods to track plan/step/goal status.
+- Do not read plan files from disk or follow plan file placeholders; use the planpilot tool for plan/step/goal info.
 - Treat tool output as authoritative. Do not invent IDs; only use IDs shown by `list`/`show`.
 - If the tool is missing or unavailable, ask the user to enable/install the plugin.
 - Record implementation details using Planpilot comments (plan/step/goal `--comment` or `comment` commands). Before starting a step or goal, think through the next actions and capture that context in comments so the plan stays actionable.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-planpilot",
-  "version": "0.1.0",
-  "description": "Planpilot plugin for OpenCode (TypeScript rewrite)",
+  "version": "0.1.2",
+  "description": "Planpilot plugin for OpenCode",
   "type": "module",
   "repository": {
     "type": "git",

package/src/index.ts

@@ -9,6 +9,15 @@ import { loadPlanpilotInstructions } from "./lib/instructions"
 
 export const PlanpilotPlugin: Plugin = async (ctx) => {
   const inFlight = new Set<string>()
+  const skipNextAuto = new Set<string>()
+  const lastIdleAt = new Map<string, number>()
+
+  const PLANPILOT_GUIDANCE = [
+    "Planpilot guidance:",
+    "- Do not read plan files from disk or follow plan file placeholders.",
+    "- Use the planpilot tool for plan/step/goal info (plan show-active, step show-next, goal list <step_id>).",
+    "- If you cannot continue or need human input, insert a new step with executor `human` before the next pending step using planpilot so auto-continue pauses.",
+  ].join("\n")
 
   const log = async (level: "debug" | "info" | "warn" | "error", message: string, extra?: Record<string, any>) => {
     try {
@@ -25,8 +34,96 @@ export const PlanpilotPlugin: Plugin = async (ctx) => {
     }
   }
 
+  type SessionMessage = {
+    info?: {
+      role?: string
+      agent?: string
+      model?: {
+        providerID: string
+        modelID: string
+      }
+      modelID?: string
+      providerID?: string
+      variant?: string
+      time?: {
+        created?: number
+      }
+      error?: {
+        name?: string
+      }
+      finish?: string
+    }
+  }
+
+  const loadRecentMessages = async (sessionID: string, limit = 200): Promise<SessionMessage[]> => {
+    const response = await ctx.client.session.messages({
+      path: { id: sessionID },
+      query: { limit },
+    })
+    const data = (response as { data?: unknown }).data ?? response
+    if (!Array.isArray(data)) return []
+    return data as SessionMessage[]
+  }
+
+  const findLastMessage = (messages: SessionMessage[], predicate: (message: SessionMessage) => boolean) => {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+      const message = messages[idx]
+      if (predicate(message)) return message
+    }
+    return undefined
+  }
+
+  const findLastMessageByRole = (messages: SessionMessage[], role: "user" | "assistant") =>
+    findLastMessage(messages, (message) => message?.info?.role === role)
+
+  const resolveAutoContext = async (sessionID: string) => {
+    const messages = await loadRecentMessages(sessionID)
+    if (!messages.length) return null
+
+    const sortedMessages = [...messages].sort((left, right) => {
+      const leftTime = left?.info?.time?.created ?? 0
+      const rightTime = right?.info?.time?.created ?? 0
+      return leftTime - rightTime
+    })
+
+    const lastUser = findLastMessage(sortedMessages, (message) => message?.info?.role === "user")
+    if (!lastUser) return { missingUser: true }
+
+    const lastAssistant = findLastMessageByRole(sortedMessages, "assistant")
+    const error = lastAssistant?.info?.error
+    const aborted = typeof error === "object" && error?.name === "MessageAbortedError"
+    const finish = lastAssistant?.info?.finish
+    const ready =
+      !lastAssistant || (typeof finish === "string" && finish !== "tool-calls" && finish !== "unknown")
+
+    const model =
+      lastUser?.info?.model ??
+      (lastUser?.info?.providerID && lastUser?.info?.modelID
+        ? { providerID: lastUser.info.providerID, modelID: lastUser.info.modelID }
+        : lastAssistant?.info?.providerID && lastAssistant?.info?.modelID
+          ? { providerID: lastAssistant.info.providerID, modelID: lastAssistant.info.modelID }
+          : undefined)
+
+    return {
+      agent: lastUser?.info?.agent ?? lastAssistant?.info?.agent,
+      model,
+      variant: lastUser?.info?.variant,
+      aborted,
+      ready,
+      missingUser: false,
+    }
+  }
+
   const handleSessionIdle = async (sessionID: string) => {
     if (inFlight.has(sessionID)) return
+    if (skipNextAuto.has(sessionID)) {
+      skipNextAuto.delete(sessionID)
+      return
+    }
+    const lastIdle = lastIdleAt.get(sessionID)
+    const now = Date.now()
+    if (lastIdle && now - lastIdle < 1000) return
+    lastIdleAt.set(sessionID, now)
     inFlight.add(sessionID)
     try {
       const app = new PlanpilotApp(openDatabase(), sessionID)
@@ -39,16 +136,32 @@ export const PlanpilotPlugin: Plugin = async (ctx) => {
       const detail = formatStepDetail(next, goals)
       if (!detail.trim()) return
 
+      const autoContext = await resolveAutoContext(sessionID)
+      if (autoContext?.missingUser) {
+        await log("warn", "auto-continue stopped: missing user context", { sessionID })
+        return
+      }
+      if (autoContext?.aborted || autoContext?.ready === false) return
+
       const message =
         "Planpilot (auto):\n" +
         "Before acting, think through the next step and its goals. Record implementation details using Planpilot comments (plan/step/goal --comment or comment commands). Continue with the next step (executor: ai). Do not ask for confirmation; proceed and report results.\n\n" +
+        PLANPILOT_GUIDANCE +
+        "\n\n" +
         detail.trimEnd()
 
+      const promptBody: any = {
+        agent: autoContext?.agent ?? undefined,
+        model: autoContext?.model ?? undefined,
+        parts: [{ type: "text" as const, text: message }],
+      }
+      if (autoContext?.variant) {
+        promptBody.variant = autoContext.variant
+      }
+
       await ctx.client.session.promptAsync({
         path: { id: sessionID },
-        body: {
-          parts: [{ type: "text", text: message }],
-        },
+        body: promptBody,
       })
     } catch (err) {
       await log("warn", "failed to auto-continue plan", { error: err instanceof Error ? err.message : String(err) })
@@ -116,6 +229,18 @@ export const PlanpilotPlugin: Plugin = async (ctx) => {
       if (instructions && !alreadyInjected) {
         output.system.push(instructions)
       }
+      const guidanceInjected = output.system.some((entry) => entry.includes("Planpilot guidance:"))
+      if (!guidanceInjected) {
+        output.system.push(PLANPILOT_GUIDANCE)
+      }
+    },
+    "experimental.session.compacting": async ({ sessionID }, output) => {
+      const hasGuidance = output.context.some((entry) => entry.includes("Planpilot guidance:"))
+      if (!hasGuidance) {
+        output.context.push(PLANPILOT_GUIDANCE)
+      }
+      skipNextAuto.add(sessionID)
+      lastIdleAt.set(sessionID, Date.now())
     },
     event: async ({ event }) => {
       if (event.type === "session.idle") {