@comfanion/usethis_todo 0.1.16-dev.8 → 0.1.16

package/index.ts

@@ -2,15 +2,19 @@ import type { Plugin } from "@opencode-ai/plugin"
 import path from "path"
 import fs from "fs/promises"
 
-import { write, read, read_five, read_by_id, setNativeStorageBase, readTodos } from "./tools"
+import { write, read, read_five, read_by_id, setNativeStorageBase, setClientStorage } from "./tools"
 
-interface TodoPruneState {
-  lastToolCallId: string | null
-}
-
-const pruneStates = new Map<string, TodoPruneState>()
+const TODO_TOOLS = new Set([
+  "usethis_todo_write",
+  "usethis_todo_read",
+  "usethis_todo_read_five",
+  "usethis_todo_read_by_id",
+])
 
 const UsethisTodoPlugin: Plugin = async ({ directory, client }) => {
+  // Set client storage API for native Storage operations
+  setClientStorage(client)
+
   // Resolve the authoritative state path from OpenCode server (non-blocking).
   // Must NOT await — server may block until plugin init completes → deadlock.
   client.path.get().then((pathInfo: any) => {
@@ -27,111 +31,112 @@ const UsethisTodoPlugin: Plugin = async ({ directory, client }) => {
   }
 
   return {
-    // Keep only the latest tool output for our TODO tools (context-efficient)
-    // Previous todo tool calls are replaced with [TODO pruned]
-    // DISABLED for now — lastToolCallId resets after reload, breaks pruning logic
-    /*
+    // Prune old TODO tool outputs + old "## TODO" snapshot text parts.
+    // Keeps only the LAST call of each tool and the LAST snapshot.
     "experimental.chat.messages.transform": async (_input: unknown, output: { messages: any[] }) => {
       const messages = output.messages || []
-      const sessionID = messages[0]?.info?.sessionID
-
-      if (!sessionID) return
-
-      const state = pruneStates.get(sessionID)
-      if (!state?.lastToolCallId) return
-
-      const prunedToolNames = new Set([
-        "usethis_todo_write",
-        "usethis_todo_read",
-        "usethis_todo_read_five",
-        "usethis_todo_read_by_id",
-        // todowrite is NOT pruned — required for TUI rendering + sidebar sync
-      ])
+      if (messages.length === 0) return
 
-      // Collect all TODO-related tool parts
-      const toolParts: { part: any; isLast: boolean }[] = []
+      // 1. Collect tool parts and snapshot text parts
+      const toolParts: any[] = []
+      const snapshotParts: any[] = []
 
       for (const msg of messages) {
         for (const part of (msg.parts || [])) {
-          if (part.type === "tool" && prunedToolNames.has(part.tool) && part.state?.status === "completed") {
-            toolParts.push({ part, isLast: part.callID === state.lastToolCallId })
+          if (
+            part.type === "tool" &&
+            TODO_TOOLS.has(part.tool) &&
+            part.state?.status === "completed"
+          ) {
+            toolParts.push(part)
+          }
+          if (
+            part.type === "text" &&
+            typeof part.text === "string" &&
+            part.text.startsWith("## TODO")
+          ) {
+            snapshotParts.push(part)
+          }
+        }
+      }
+
+      // 2. Collect parts to remove (old tool calls + old snapshots)
+      const partsToRemove = new Set<any>()
+
+      // Keep only last call per tool — remove all older ones entirely
+      if (toolParts.length > 1) {
+        const lastByTool = new Map<string, any>()
+        for (const part of toolParts) {
+          lastByTool.set(part.tool, part)
+        }
+        for (const part of toolParts) {
+          if (part !== lastByTool.get(part.tool)) {
+            partsToRemove.add(part)
           }
         }
       }
 
-      if (toolParts.length === 0) return
+      // Keep only last "## TODO" snapshot — remove all older ones
+      if (snapshotParts.length > 1) {
+        const lastSnapshot = snapshotParts[snapshotParts.length - 1]
+        for (const part of snapshotParts) {
+          if (part !== lastSnapshot) {
+            partsToRemove.add(part)
+          }
+        }
+      }
 
-      // Prune old tool parts — clear BOTH input and output, keep only last
-      for (const { part, isLast } of toolParts) {
-        if (!isLast) {
-          part.state.output = "[TODO pruned]"
-          if (part.state.input) part.state.input = {}
+      // 3. Remove collected parts from messages
+      if (partsToRemove.size > 0) {
+        for (const msg of messages) {
+          if (!Array.isArray(msg.parts)) continue
+          msg.parts = msg.parts.filter((p: any) => !partsToRemove.has(p))
         }
+        // Remove empty messages
+        output.messages = messages.filter((msg: any) => (msg.parts || []).length > 0)
       }
     },
-    */
 
     tool: {
-      // Our enhanced tools — AI uses these for graph/dependencies
       usethis_todo_write: write,
       usethis_todo_read: read,
       usethis_todo_read_five: read_five,
       usethis_todo_read_by_id: read_by_id,
-
-      // Native override — emulates todowrite for sidebar refresh + TUI checklist
-      // Reads the data our write already stored and returns native JSON format.
-      // tool.execute.after on usethis_todo_write auto-invokes this via description hint.
-      todowrite: {
-        description: write.description, // Use same description as write
-        args: write.args, // Use same args as write
-        async execute(args: any, context: any) {
-          // If args provided, perform write first
-          if (args.todos && args.todos.length > 0) {
-            await write.execute(args, context)
-          }
-          
-          // Then return native JSON format
-          const todos = await readTodos(context.sessionID, context.directory)
-          return JSON.stringify(todos.map(t => ({
-            id: t.id,
-            content: t.content,
-            status: t.status,
-            priority: t.priority,
-          })))
-        },
-      },
     },
 
-    // Set nicer titles in TUI + track prune state
-    "tool.execute.after": async (input, output) => {
-      const ourTools = new Set(["usethis_todo_write", "usethis_todo_read", "usethis_todo_read_five", "usethis_todo_read_by_id", "todowrite"])
-      if (!ourTools.has(input.tool)) return
-
-      // Update prune state with latest call ID (only for our custom tools, not todowrite)
-      if (input.tool.startsWith("usethis_todo_")) {
-        const sessionID = input.sessionID
-        if (sessionID) {
-          const state = pruneStates.get(sessionID) || { lastToolCallId: null }
-          state.lastToolCallId = input.callID
-          pruneStates.set(sessionID, state)
-        }
-      }
+    // Publish TODO output as a text message in chat via session.prompt().
+    // TUI GenericTool does not render output — this injects a visible "## TODO" text part.
+    // Also prunes old "## TODO" snapshots in messages.transform.
+    "tool.execute.after": async (input: any, output: any) => {
+      if (!TODO_TOOLS.has(input.tool)) return
 
       const out = output.output || ""
 
-      // Set a nicer title in TUI
+      // Set title
       if (input.tool === "usethis_todo_write") {
         const match = out.match(/\[(\d+)\/(\d+) done/)
-        output.title = match ? `TODO: ${match[2]} tasks` : "TODO updated"
+        output.title = match ? `TODO [${match[1]}/${match[2]} done]` : "TODO updated"
       } else if (input.tool === "usethis_todo_read") {
         const match = out.match(/\[(\d+)\/(\d+) done, (\d+) in progress\]/)
-        output.title = match ? `TODO [${match[1]}/${match[2]} done]` : "TODO list"
+        output.title = match ? `TODO [${match[1]}/${match[2]} done, ${match[3]} wip]` : "TODO list"
       } else if (input.tool === "usethis_todo_read_five") {
         output.title = "Next 5 tasks"
       } else if (input.tool === "usethis_todo_read_by_id") {
         output.title = "Task details"
-      } else if (input.tool === "todowrite") {
-        output.title = "Sidebar sync"
+      }
+
+      // Publish snapshot into chat so user sees it in TUI
+      const text = ["## TODO", "", out].join("\n")
+      try {
+        await client?.session?.prompt?.({
+          path: { id: input.sessionID },
+          body: {
+            noReply: true,
+            parts: [{ type: "text", text }],
+          },
+        })
+      } catch {
+        // non-fatal — prompt API may not be available
       }
     },
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/usethis_todo",
-  "version": "0.1.16-dev.8",
+  "version": "0.1.16",
   "description": "OpenCode plugin: enhanced TODO tools (dual storage + dependency graph)",
   "type": "module",
   "main": "./index.ts",

package/tools.ts

@@ -8,8 +8,8 @@
  *   usethis_todo_read_by_id({ id })       - read task by id with its blockers
  *
  * Storage:
- *   Unified: Native OpenCode storage (TUI compatible)
- *   Path resolved via client.path.get()
+ *   Dual: Native OpenCode storage (via client.storage) + Local file backup (.opencode/session-todo/)
+ *   Native storage uses await client.storage.write(["todo", sessionID], todos)
  *
  * Features:
  *   - Stores FULL enhanced schema (blockedBy, priority, etc) in the native file
@@ -23,6 +23,59 @@ import path from "path"
 import os from "os"
 import fs from "fs/promises"
 
+// ============================================================================
+// Client API Wrapper (Storage + Bus)
+// ============================================================================
+
+let _client: any = null
+
+/**
+ * Set the OpenCode client API.
+ * Called during plugin initialization with the full client object.
+ */
+export function setClientStorage(client: any): void {
+  _client = client
+}
+
+/**
+ * Write to native OpenCode storage.
+ * Equivalent to: Storage.write(["todo", sessionID], todos)
+ */
+async function writeNativeStorage(key: string[], value: any): Promise<void> {
+  if (!_client?.storage?.write) return
+  try {
+    await _client.storage.write(key, value)
+  } catch {
+    // ignore — native storage not available
+  }
+}
+
+/**
+ * Read from native OpenCode storage.
+ * Equivalent to: Storage.read<T>(["todo", sessionID])
+ */
+async function readNativeStorage<T>(key: string[]): Promise<T | null> {
+  if (!_client?.storage?.read) return null
+  try {
+    return await _client.storage.read(key)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Publish event to OpenCode bus.
+ * Equivalent to: Bus.publish(Event.Updated, { sessionID, todos })
+ */
+async function publishBusEvent(event: string, data: any): Promise<void> {
+  if (!_client?.bus?.publish) return
+  try {
+    await _client.bus.publish(event, data)
+  } catch {
+    // ignore — bus not available from plugins
+  }
+}
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -178,8 +231,6 @@ async function getStoragePaths(sid: string): Promise<string[]> {
 // Mapping Logic (Enhanced <-> Native)
 // ============================================================================
 
-
-
 function toNativePriority(priority: string): string {
   switch (priority) {
     case "CRIT": return "high"
@@ -195,6 +246,21 @@ function toNativePriority(priority: string): string {
 // ============================================================================
 
 export async function readTodos(sid: string, directory?: string): Promise<Todo[]> {
+  // 1. Try Native OpenCode Storage first (primary)
+  try {
+    const nativeData = await readNativeStorage<Todo[]>(["todo", sid])
+    if (Array.isArray(nativeData) && nativeData.length > 0) {
+      return nativeData.map((t: any) => {
+        const realStatus = t.usethisStatus || t.status
+        const realPriority = t.usethisPriority || t.priority
+        return normalizeTodo({ ...t, status: realStatus, priority: realPriority })
+      })
+    }
+  } catch {
+    // fallback to file storage
+  }
+
+  // 2. Fallback to file storage
   try {
     const storagePaths = await getStoragePaths(sid)
     for (const storagePath of storagePaths) {
@@ -202,13 +268,14 @@ export async function readTodos(sid: string, directory?: string): Promise<Todo[]
         const raw = JSON.parse(await fs.readFile(storagePath, "utf-8"))
         if (Array.isArray(raw)) {
           return raw.map((t: any) => {
-            // Restore "ready" status if it was saved
             const realStatus = t.usethisStatus || t.status
             const realPriority = t.usethisPriority || t.priority
             return normalizeTodo({ ...t, status: realStatus, priority: realPriority })
           })
         }
-      } catch { continue }
+      } catch {
+        continue
+      }
     }
     return []
   } catch {
@@ -224,12 +291,12 @@ function getEnhancedPath(sid: string, directory?: string): string {
 async function writeTodos(todos: Todo[], sid: string, directory?: string): Promise<void> {
   const storagePaths = await getStoragePaths(sid)
   const enhancedPath = getEnhancedPath(sid, directory)
-  
+
   const storageTodos = todos.map(t => {
     // Status is already native — map "ready" to "in_progress" for native storage
     const nativeStatus = t.status === "ready" ? "in_progress" : t.status
     const nativePriority = toNativePriority(t.priority)
-    
+
     return {
       ...t,
       status: nativeStatus,
@@ -242,27 +309,35 @@ async function writeTodos(todos: Todo[], sid: string, directory?: string): Promi
 
   const json = JSON.stringify(storageTodos, null, 2)
 
-  // 1. Write to Global Storages (for Sidebar)
+  // 1. Write to Native OpenCode Storage (primary)
+  try {
+    await writeNativeStorage(["todo", sid], storageTodos)
+  } catch {
+    // ignore
+  }
+
+  // 2. Write to Global Storages (for Sidebar - fallback)
   await Promise.allSettled(
     storagePaths.map(async (p) => {
       try {
         await fs.mkdir(path.dirname(p), { recursive: true })
         await fs.writeFile(p, json, "utf-8")
-        await logAction(directory || "", "debug", `Writing to global: ${p}`)
-      } catch (e) {
-        await logAction(directory || "", "error", `Global write failed for ${p}: ${String(e)}`)
+      } catch {
+        // ignore
       }
     })
   )
 
-  // 2. Write to Local Storage (for User visibility/Git)
+  // 3. Write to Local Storage (for User visibility/Git - backup)
   try {
     await fs.mkdir(path.dirname(enhancedPath), { recursive: true })
     await fs.writeFile(enhancedPath, json, "utf-8")
-    await logAction(directory || "", "debug", `Writing to local: ${enhancedPath}`)
-  } catch (e) {
-    await logAction(directory || "", "error", `Local write failed: ${String(e)}`)
+  } catch {
+    // ignore
   }
+
+  // 4. Publish "todo.updated" event to Bus
+  await publishBusEvent("todo.updated", { sessionID: sid, todos: storageTodos })
 }
 
 // ============================================================================
@@ -565,12 +640,40 @@ Set merge: false to replace the entire list.`,
       const merged = [...byId.values()]
       await writeTodos(merged, context.sessionID, context.directory)
       await logAction(context.directory, "write-merge", `Merged ${args.todos.length} task(s) in session ${context.sessionID}`)
+
+      // Try to trigger sidebar update via metadata
+      try {
+        const nativeTodos = merged.map(t => ({
+          id: t.id,
+          content: t.content,
+          status: t.status === "ready" ? "in_progress" : t.status,
+          priority: toNativePriority(t.priority),
+        }))
+        await context.metadata({ todos: nativeTodos })
+      } catch {
+        // metadata not available — sidebar won't update
+      }
+
       return `✅ Updated ${args.todos.length} task(s)\n\n${formatGraph(analyzeGraph(merged))}`
     } else {
       // REPLACE mode: replace entire list
       const todos = args.todos.map((t: any) => normalizeTodo({ ...t, createdAt: t.createdAt || now, updatedAt: now }))
       await writeTodos(todos, context.sessionID, context.directory)
       await logAction(context.directory, "write", `Created/Updated ${todos.length} tasks in session ${context.sessionID}`)
+
+      // Try to trigger sidebar update via metadata
+      try {
+        const nativeTodos = todos.map(t => ({
+          id: t.id,
+          content: t.content,
+          status: t.status === "ready" ? "in_progress" : t.status,
+          priority: toNativePriority(t.priority),
+        }))
+        await context.metadata({ todos: nativeTodos })
+      } catch {
+        // metadata not available — sidebar won't update
+      }
+
       return `✅ Updated ${todos.length} task(s)\n\n${formatGraph(analyzeGraph(todos))}`
     }
   },