@comfanion/workflow 4.38.3-dev.0 → 4.38.3-dev.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.38.3-dev.0",
+  "version": "4.38.3-dev.1",
   "description": "Initialize OpenCode Workflow system for AI-assisted development with semantic code search",
   "type": "module",
   "bin": {

package/src/build-info.json

@@ -1,6 +1,6 @@
 {
-  "version": "4.38.3-dev.0",
-  "buildDate": "2026-01-28T10:28:17.932Z",
+  "version": "4.38.3-dev.1",
+  "buildDate": "2026-01-28T11:01:04.180Z",
   "files": [
     ".gitignore",
     "config.yaml",

package/src/opencode/plugins/__tests__/usethis-todo.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from "bun:test"
 import { readFile } from "fs/promises"
 import { join } from "path"
 import { createTempDir, cleanupTempDir } from "./helpers/mock-ctx"
-import { write, update, read, get_by_id } from "../../tools/usethis_todo"
+import { write, update, read, read_by_id, read_five } from "../../tools/usethis_todo"
 
 describe("usethis_todo tool", () => {
   let tempDir: string
@@ -103,7 +103,31 @@ describe("usethis_todo tool", () => {
     expect(output).toContain("Available Now")
   })
 
-  it("get_by_id returns single task", async () => {
+  it("read_five returns up to 5 available tasks with description", async () => {
+    const ctx = { sessionID: "sess-five", directory: tempDir } as any
+    await write.execute(
+      {
+        todos: [
+          { id: "A1", content: "T1", description: "D1", status: "ready", priority: "HIGH" },
+          { id: "A2", content: "T2", status: "ready", priority: "MED" },
+          { id: "A3", content: "T3", status: "ready", priority: "LOW" },
+          { id: "A4", content: "T4", status: "ready", priority: "LOW" },
+          { id: "A5", content: "T5", status: "ready", priority: "LOW" },
+          { id: "A6", content: "T6", status: "ready", priority: "LOW" },
+        ],
+      },
+      ctx
+    )
+
+    const out = await read_five.execute({}, ctx)
+    expect(out).toContain("Next 5")
+    expect(out).toContain("A1")
+    expect(out).toContain("T1")
+    expect(out).toContain("D1")
+    expect(out).toContain("+1 more")
+  })
+
+  it("read_by_id returns task with resolved blockers", async () => {
     const ctx = { sessionID: "sess-get", directory: tempDir } as any
     await write.execute(
       {
@@ -116,23 +140,40 @@ describe("usethis_todo tool", () => {
             priority: "HIGH",
             blockedBy: ["B1"],
           },
+          {
+            id: "B1",
+            content: "Blocker task",
+            status: "done",
+            priority: "LOW",
+            blockedBy: ["C1"],
+          },
+          {
+            id: "C1",
+            content: "Root blocker",
+            status: "pending",
+            priority: "MED",
+          },
         ],
       },
       ctx
     )
 
-    const out = await get_by_id.execute({ id: "A1" }, ctx)
+    const out = await read_by_id.execute({ id: "A1" }, ctx)
     expect(out).toContain("id: A1")
     expect(out).toContain("content:")
     expect(out).toContain("Task content")
     expect(out).toContain("blockedBy: B1")
     expect(out).toContain("description:")
     expect(out).toContain("More details")
+
+    expect(out).toContain("blockedBy (resolved):")
+    expect(out).toContain("- B1")
+    expect(out).toContain("- C1")
   })
 
-  it("get_by_id returns not found", async () => {
+  it("read_by_id returns not found", async () => {
     const ctx = { sessionID: "sess-miss", directory: tempDir } as any
-    const out = await get_by_id.execute({ id: "NOPE" }, ctx)
+    const out = await read_by_id.execute({ id: "NOPE" }, ctx)
     expect(out).toContain("not found")
   })
 })

package/src/opencode/plugins/usethis-todo-publish.ts

@@ -9,10 +9,16 @@ import type { Plugin } from "@opencode-ai/plugin"
 export const UsethisTodoPublish: Plugin = async ({ client }) => {
   return {
     "tool.execute.after": async (input, output) => {
-      if (input.tool !== "usethis_todo_write" && input.tool !== "usethis_todo_update") return
+      if (
+          input.tool !== "usethis_todo_write"
+          && input.tool !== "usethis_todo_update"
+          && input.tool !== "usethis_todo_read_five"
+          && input.tool !== "usethis_todo_read"
+          && input.tool !== "usethis_todo_read_by_id"
+      ) return
 
       const text = [
-          `## TODO`,
+        `## TODO`,
         // `session: ${input.sessionID}`,
         "",
         output.output

package/src/opencode/tools/usethis_todo.ts

@@ -1,16 +1,17 @@
 /**
  * TODO Tool with Dependencies & Priority — v3 (dual storage)
- * 
+ *
  * 4 commands:
  *   usethis_todo_write({ todos: [...] })    - create/update TODO list
  *   usethis_todo_read()                     - read TODO with graph analysis
- *   usethis_todo_read_next_five()           - get next 5 available tasks
+ *   usethis_todo_read_five()           - get next 5 available tasks
+ *   usethis_todo_read_by_id()           - get next 5 available tasks
  *   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)
- * 
+ *
  * Features:
  * - Hierarchical IDs: E01-S01-T01
  * - Dependencies: blockedBy field
@@ -116,7 +117,7 @@ function toNative(todo: Todo): NativeTodo {
     MED: "medium",
     LOW: "low",
   }
-  
+
   const deps = todo.blockedBy?.length ? ` [← ${todo.blockedBy.join(", ")}]` : ""
   const desc = todo.description?.trim() ? ` — ${todo.description.trim()}` : ""
 
@@ -141,16 +142,16 @@ async function writeTodos(todos: Todo[], sid: string, directory?: string): Promi
   const enhancedPath = getEnhancedPath(sid, directory)
   await fs.mkdir(path.dirname(enhancedPath), { recursive: true })
   await fs.writeFile(enhancedPath, JSON.stringify(todos, null, 2), "utf-8")
-  
+
   // 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")
-      }),
+        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
@@ -164,7 +165,7 @@ async function writeTodos(todos: Todo[], sid: string, directory?: string): Promi
 function analyzeGraph(todos: Todo[]): TodoGraph {
   const blocked: Record<string, string[]> = {}
   const availableTodos: Todo[] = []
-  
+
   for (const todo of todos) {
     if (todo.status !== "ready") continue
     const activeBlockers = (todo.blockedBy || []).filter(id => {
@@ -177,11 +178,11 @@ function analyzeGraph(todos: Todo[]): TodoGraph {
       blocked[todo.id] = activeBlockers
     }
   }
-  
+
   const P: Record<string, number> = { CRIT: 0, HIGH: 1, MED: 2, LOW: 3 }
   availableTodos.sort((a, b) => (P[a.priority] ?? 2) - (P[b.priority] ?? 2))
   const available = availableTodos.map(t => t.id)
-  
+
   // Parallel groups
   const parallel: string[][] = []
   const seen = new Set<string>()
@@ -200,7 +201,7 @@ function analyzeGraph(todos: Todo[]): TodoGraph {
     }
     if (group.length > 0) parallel.push(group)
   }
-  
+
   return { todos, available, parallel, blocked }
 }
 
@@ -216,9 +217,9 @@ function formatGraph(graph: TodoGraph): string {
   const total = todos.length
   const done = todos.filter(t => t.status === "done").length
   const wip = todos.filter(t => t.status === "in_progress").length
-  
+
   const lines: string[] = [`═══ TODO Graph [${done}/${total} done, ${wip} in progress] ═══`, ""]
-  
+
   lines.push("All Tasks:")
   for (const t of todos) {
     const deps = t.blockedBy?.length ? ` ← ${t.blockedBy.join(", ")}` : ""
@@ -226,7 +227,7 @@ function formatGraph(graph: TodoGraph): string {
     lines.push(`  ${SI(t.status)} ${PE(t.priority)} ${t.id}: ${t.content}${desc}${deps}`)
   }
   lines.push("")
-  
+
   if (graph.available.length > 0) {
     lines.push("Available Now:")
     for (const id of graph.available) {
@@ -238,14 +239,14 @@ function formatGraph(graph: TodoGraph): string {
     lines.push("Available Now: none")
   }
   lines.push("")
-  
+
   const multi = graph.parallel.filter(g => g.length > 1)
   if (multi.length > 0) {
     lines.push("Parallel Groups:")
     multi.forEach((g, i) => lines.push(`  Group ${i + 1}: ${g.join(", ")}`))
     lines.push("")
   }
-  
+
   if (Object.keys(graph.blocked).length > 0) {
     lines.push("Blocked:")
     for (const [id, blockers] of Object.entries(graph.blocked)) {
@@ -254,7 +255,7 @@ function formatGraph(graph: TodoGraph): string {
       lines.push(`  ⊗ ${id}: ${t?.content}${desc} ← waiting: ${blockers.join(", ")}`)
     }
   }
-  
+
   return lines.join("\n")
 }
 
@@ -266,14 +267,14 @@ export const write = tool({
   description: "Create or update TODO list. TODOv2 (Prefer this instead of TODO)",
   args: {
     todos: tool.schema.array(
-      tool.schema.object({
-        id: tool.schema.string().describe("Task ID in concat format: E01-S01-T01"),
-        content: tool.schema.string().describe("Short task summary"),
-        description: tool.schema.string().optional().describe("Full task description"),
-        status: tool.schema.string().describe("pending | ready | in_progress | waiting_review | done | cancelled"),
-        priority: tool.schema.string().describe("CRIT | HIGH | MED | LOW"),
-        blockedBy: tool.schema.array(tool.schema.string()).optional().describe("IDs of blocking tasks"),
-      })
+        tool.schema.object({
+          id: tool.schema.string().describe("Task ID in concat format: E01-S01-T01"),
+          content: tool.schema.string().describe("Short task summary"),
+          description: tool.schema.string().optional().describe("Full task description"),
+          status: tool.schema.string().describe("pending | ready | in_progress | waiting_review | done | cancelled"),
+          priority: tool.schema.string().describe("CRIT | HIGH | MED | LOW"),
+          blockedBy: tool.schema.array(tool.schema.string()).optional().describe("IDs of blocking tasks"),
+        })
     ).describe("Array of todos"),
   },
   async execute(args, context) {
@@ -284,7 +285,7 @@ export const write = tool({
   },
 })
 
-export const read_next_five = tool({
+export const read_five = tool({
   description: "Read current TODO list. Shows Next 5 tasks.",
   args: {},
   async execute(_args, context) {
@@ -316,8 +317,8 @@ export const read = tool({
   },
 })
 
-export const get_by_id = tool({
-  description: "Get one task by id.",
+export const read_by_id = tool({
+  description: "Read task by id.",
   args: {
     id: tool.schema.string().describe("Task ID"),
   },
@@ -326,31 +327,78 @@ export const get_by_id = tool({
     const todo = todos.find(t => t.id === args.id)
     if (!todo) return `❌ Task ${args.id} not found`
 
-    const deps = todo.blockedBy?.length ? `\nblockedBy: ${todo.blockedBy.join(", ")}` : ""
-    const desc = todo.description?.trim() ? `\n\ndescription:\n${todo.description.trim()}` : ""
-    return [
-      `id: ${todo.id}`,
-      `priority: ${todo.priority}`,
-      `status: ${todo.status}`,
-      deps,
-      `\ncontent:\n${todo.content}`,
-      desc,
-    ].filter(Boolean).join("\n")
+    const byId = new Map(todos.map(t => [t.id, t]))
+
+    // Resolve blockers transitively (task -> blockedBy -> blockedBy ...)
+    const blockers: Todo[] = []
+    const missing: string[] = []
+    const seen = new Set<string>()
+    const stack = [...(todo.blockedBy || [])]
+
+    while (stack.length > 0) {
+      const id = stack.shift()!
+      if (seen.has(id)) continue
+      seen.add(id)
+
+      const t = byId.get(id)
+      if (!t) {
+        missing.push(id)
+        continue
+      }
+
+      blockers.push(t)
+      if (t.blockedBy?.length) stack.push(...t.blockedBy)
+    }
+
+    const lines: string[] = []
+    lines.push(`id: ${todo.id}`)
+    lines.push(`priority: ${todo.priority}`)
+    lines.push(`status: ${todo.status}`)
+
+    if (todo.blockedBy?.length) {
+      lines.push(`blockedBy: ${todo.blockedBy.join(", ")}`)
+    }
+
+    lines.push("")
+    lines.push("content:")
+    lines.push(todo.content)
+
+    if (todo.description?.trim()) {
+      lines.push("")
+      lines.push("description:")
+      lines.push(todo.description.trim())
+    }
+
+    if (blockers.length) {
+      lines.push("")
+      lines.push("blockedBy (resolved):")
+      for (const b of blockers) {
+        const d = b.description?.trim() ? ` — ${b.description.trim()}` : ""
+        lines.push(`- ${b.id} [${b.status}] ${b.priority}: ${b.content}${d}`)
+      }
+    }
+
+    if (missing.length) {
+      lines.push("")
+      lines.push(`blockedBy missing: ${missing.join(", ")}`)
+    }
+
+    return lines.join("\n")
   },
 })
 
 export const update = tool({
-  description: "Update tasks. Same interface as write, but merges by id.",
+  description: "Update task(s). Send 1 or many for update",
   args: {
     todos: tool.schema.array(
-      tool.schema.object({
-        id: tool.schema.string().describe("Task ID in concat format: E01-S01-T01"),
-        content: tool.schema.string().describe("Short task summary"),
-        description: tool.schema.string().optional().describe("Full task description"),
-        status: tool.schema.string().describe("pending | ready | in_progress | waiting_review | done | cancelled"),
-        priority: tool.schema.string().describe("CRIT | HIGH | MED | LOW"),
-        blockedBy: tool.schema.array(tool.schema.string()).optional().describe("IDs of blocking tasks"),
-      })
+        tool.schema.object({
+          id: tool.schema.string().describe("Task ID in concat format: E01-S01-T01"),
+          content: tool.schema.string().describe("Short task summary"),
+          description: tool.schema.string().optional().describe("Full task description"),
+          status: tool.schema.string().describe("pending | ready | in_progress | waiting_review | done | cancelled"),
+          priority: tool.schema.string().describe("CRIT | HIGH | MED | LOW"),
+          blockedBy: tool.schema.array(tool.schema.string()).optional().describe("IDs of blocking tasks"),
+        })
     ).describe("Array of todos to update"),
   },
   async execute(args, context) {