@comfanion/usethis_todo 0.1.15-dev.10 → 0.1.15-dev.11

package/index.ts

@@ -2,7 +2,7 @@ import type { Plugin } from "@opencode-ai/plugin"
 import path from "path"
 import fs from "fs/promises"
 
-import { write, read, read_five, read_by_id, update } from "./tools"
+import { write, read, read_five, read_by_id, update, setNativeStorageBase } from "./tools"
 
 interface TodoPruneState {
   lastToolCallId: string | null
@@ -11,6 +11,13 @@ interface TodoPruneState {
 const pruneStates = new Map<string, TodoPruneState>()
 
 const UsethisTodoPlugin: Plugin = async ({ directory, 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) => {
+    const state = pathInfo?.data?.state
+    if (state) setNativeStorageBase(state)
+  }).catch(() => {})
+
   // Ensure storage directory exists on init
   try {
     const todoDir = path.join(directory, ".opencode", "session-todo")

package/package.json

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

package/tools.ts

@@ -1,5 +1,5 @@
 /**
- * TODO Tool with Dependencies & Priority — v3 (dual storage)
+ * TODO Tool with Dependencies & Priority — v3 (unified storage)
  *
  * 4 commands:
  *   usethis_todo_write({ todos: [...] })    - create/update TODO list
@@ -9,15 +9,13 @@
  *   usethis_todo_update(id, field, value)   - update any task field
  *
  * Storage:
- *   Enhanced: .opencode/session-todos/{sid}.json  (title, blockedBy, graph)
- *   Native:  ~/.local/share/opencode/storage/todo/{sid}.json  (TUI display)
+ *   Unified: Native OpenCode storage (TUI compatible)
+ *   Path resolved via client.path.get()
  *
  * Features:
- * - Hierarchical IDs: E01-S01-T01
- * - Dependencies: blockedBy field
- * - Priority: CRIT | HIGH | MED | LOW (auto-sorted)
- * - Graph: shows available, blocked, parallel tasks
- * - Dual write: native OpenCode storage for TUI integration
+ *   - Stores FULL enhanced schema (blockedBy, priority, etc) in the native file
+ *   - Maps statuses to native values (pending/completed) for Sidebar compatibility
+ *   - Preserves original statuses in `usethisStatus` field
  */
 
 import { tool } from "@opencode-ai/plugin"
@@ -79,6 +77,10 @@ interface Todo {
   createdAt?: number
   updatedAt?: number
   
+  // Shadow fields for native compatibility
+  usethisStatus?: string    // The REAL status (todo, ready, etc)
+  usethisPriority?: string  // The REAL priority (CRIT, HIGH, etc)
+
   // Mind extensions (backward compatible - optional)
   files?: TodoFile[]                // Associated files
   tools?: TodoTool[]                // Associated tool calls
@@ -93,13 +95,6 @@ interface Todo {
   }
 }
 
-interface NativeTodo {
-  id: string
-  content: string         // "title: content" combined
-  status: string          // pending | in_progress | completed | cancelled
-  priority: string        // high | medium | low
-}
-
 interface TodoGraph {
   todos: Todo[]
   available: string[]
@@ -108,19 +103,24 @@ interface TodoGraph {
 }
 
 // ============================================================================
-// Storage — dual write
+// Storage — Unified Global
 // ============================================================================
 
+let _nativeStorageBase: string | null = null
+
+/**
+ * Set the native storage base path (OpenCode's state directory).
+ * Called once during plugin initialization with the result of client.path.get().
+ */
+export function setNativeStorageBase(statePath: string): void {
+  _nativeStorageBase = statePath
+}
+
 // Resolve project directory (context.directory may be undefined via MCP)
 function dir(directory?: string): string {
   return directory || process.env.OPENCODE_PROJECT_DIR || process.cwd()
 }
 
-// Enhanced storage path (project-local)
-function getEnhancedPath(sid: string, directory?: string): string {
-  return path.join(dir(directory), ".opencode", "session-todo", `${sid || "current"}.json`)
-}
-
 async function logAction(directory: string, action: string, details: string): Promise<void> {
   try {
     const logPath = path.join(dir(directory), ".opencode", "todo.log")
@@ -150,72 +150,133 @@ async function getNativeDataDirs(): Promise<string[]> {
   return [...dirs]
 }
 
-async function getNativePaths(sid: string): Promise<string[]> {
-  const baseDirs = await getNativeDataDirs()
+async function getStoragePath(sid: string): Promise<string> {
   const file = `${sid || "current"}.json`
-  return baseDirs.map((base) => path.join(base, "opencode", "storage", "todo", file))
-}
 
-// Map our format → native format
-function toNative(todo: Todo): NativeTodo {
-  // Status mapping: our → native
-  const statusMap: Record<string, string> = {
-    todo: "pending",
-    in_progress: "in_progress",
-    ready: "in_progress",       // native has no "ready"
-    finished: "in_progress",    // back-compat
-    done: "completed",          // native uses "completed" not "done"
-    cancelled: "cancelled",
+  // 1. Prefer authoritative path from OpenCode server
+  if (_nativeStorageBase) {
+    return path.join(_nativeStorageBase, "storage", "todo", file)
   }
-  // Priority mapping: CRIT/HIGH/MED/LOW → high/medium/low
-  const prioMap: Record<string, string> = {
-    CRIT: "high",
-    HIGH: "high",
-    MED: "medium",
-    LOW: "low",
+
+  // 2. Fallback: guess from well-known data dirs (first one that exists or default)
+  const baseDirs = await getNativeDataDirs()
+  // Try to find one that exists
+  for (const base of baseDirs) {
+    try {
+      await fs.access(base)
+      return path.join(base, "opencode", "storage", "todo", file)
+    } catch {}
   }
+  
+  // Default to first one
+  return path.join(baseDirs[0], "opencode", "storage", "todo", file)
+}
 
-  const deps = todo.blockedBy?.length ? ` [← ${todo.blockedBy.join(", ")}]` : ""
-  const desc = todo.description?.trim() ? ` — ${todo.description.trim()}` : ""
-  const rel = todo.releases?.length ? ` [rel: ${todo.releases.join(", ")}]` : ""
+// ============================================================================
+// Mapping Logic (Enhanced <-> Native)
+// ============================================================================
+
+function toNativeStatus(status: string): string {
+  switch (status) {
+    case "todo": return "pending"
+    case "in_progress": return "in_progress"
+    case "ready": return "in_progress" // Sidebar has no 'ready'
+    case "done": return "completed"
+    case "cancelled": return "cancelled"
+    default: return "pending"
+  }
+}
+
+function fromNativeStatus(nativeStatus: string, originalStatus?: string): string {
+  // If we have the original status stored, prefer it
+  if (originalStatus) return originalStatus
+
+  // Otherwise map back (lossy for ready/todo distinction)
+  switch (nativeStatus) {
+    case "pending": return "todo"
+    case "in_progress": return "in_progress"
+    case "completed": return "done"
+    case "cancelled": return "cancelled"
+    default: return "todo"
+  }
+}
 
-  return {
-    id: todo.id,
-    content: `${todo.content}${desc}${rel}${deps}`,
-    status: statusMap[todo.status] || "pending",
-    priority: prioMap[todo.priority] || "medium",
+function toNativePriority(priority: string): string {
+  switch (priority) {
+    case "CRIT": return "high"
+    case "HIGH": return "high"
+    case "MED": return "medium"
+    case "LOW": return "low"
+    default: return "medium"
   }
 }
 
+// ============================================================================
+// Read / Write
+// ============================================================================
+
 async function readTodos(sid: string, directory?: string): Promise<Todo[]> {
   try {
-    const raw = JSON.parse(await fs.readFile(getEnhancedPath(sid, directory), "utf-8"))
+    const storagePath = await getStoragePath(sid)
+    const raw = JSON.parse(await fs.readFile(storagePath, "utf-8"))
     if (!Array.isArray(raw)) return []
-    return raw.map((t: any) => normalizeTodo(t))
+    
+    return raw.map((t: any) => {
+      // Restore our rich status from shadow field if present
+      const realStatus = fromNativeStatus(t.status, t.usethisStatus)
+      const realPriority = t.usethisPriority || t.priority // Fallback if not shadowed
+
+      return normalizeTodo({
+        ...t,
+        status: realStatus,
+        priority: realPriority
+      })
+    })
   } catch {
     return []
   }
 }
 
 async function writeTodos(todos: Todo[], sid: string, directory?: string): Promise<void> {
-  // 1. Enhanced storage (our full format)
-  const enhancedPath = getEnhancedPath(sid, directory)
-  await fs.mkdir(path.dirname(enhancedPath), { recursive: true })
-  await fs.writeFile(enhancedPath, JSON.stringify(todos, null, 2), "utf-8")
+  const storagePath = await getStoragePath(sid)
+  
+  // Prepare for storage:
+  // 1. Set native-compatible fields (status, priority)
+  // 2. Store real values in shadow fields (usethisStatus, usethisPriority)
+  // 3. Keep all other fields (blockedBy, etc)
+  
+  const storageTodos = todos.map(t => {
+    const nativeStatus = toNativeStatus(t.status)
+    const nativePriority = toNativePriority(t.priority)
+    
+    const deps = t.blockedBy?.length ? ` [← ${t.blockedBy.join(", ")}]` : ""
+    const desc = t.description?.trim() ? ` — ${t.description.trim()}` : ""
+    const rel = t.releases?.length ? ` [rel: ${t.releases.join(", ")}]` : ""
+
+    return {
+      ...t,
+      // Native fields
+      status: nativeStatus,
+      priority: nativePriority,
+      content: t.content, // Keep content clean? Or append deps?
+      // Sidebar usually displays 'content'. If we want deps visible in sidebar, we should append them.
+      // But if we append them, we dirty the content for next read.
+      // Let's NOT append to content in the object, but maybe the sidebar reads 'content'.
+      // Wait, if we don't append deps to content, sidebar won't show them.
+      // But if we do, 'content' grows every time we read/write?
+      // Solution: We store 'originalContent' or just assume we can parse it back?
+      // Better: The sidebar likely just shows 'content'.
+      // Let's keep 'content' clean in the JSON. If the sidebar supports 'description', great.
+      // If not, the user sees just the title. That's acceptable for "Native Status".
+      
+      // Shadow fields (our source of truth)
+      usethisStatus: t.status,
+      usethisPriority: t.priority
+    }
+  })
 
-  // 2. Native storage (for TUI display)
-  const nativeTodos = todos.map(toNative)
-  try {
-    const nativePaths = await getNativePaths(sid)
-    await Promise.allSettled(
-      nativePaths.map(async (nativePath) => {
-        await fs.mkdir(path.dirname(nativePath), { recursive: true })
-        await fs.writeFile(nativePath, JSON.stringify(nativeTodos, null, 2), "utf-8")
-      }),
-    )
-  } catch {
-    // Native write failure is non-fatal
-  }
+  await fs.mkdir(path.dirname(storagePath), { recursive: true })
+  await fs.writeFile(storagePath, JSON.stringify(storageTodos, null, 2), "utf-8")
 }
 
 // ============================================================================
@@ -319,6 +380,10 @@ function normalizeTodo(input: any): Todo {
   if (input.searches) normalized.searches = input.searches
   if (input.context) normalized.context = input.context
   if (input.cleanup) normalized.cleanup = input.cleanup
+  
+  // Preserve shadow fields
+  if (input.usethisStatus) normalized.usethisStatus = input.usethisStatus
+  if (input.usethisPriority) normalized.usethisPriority = input.usethisPriority
 
   return normalized
 }