@comfanion/workflow 4.34.0 → 4.36.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.34.0",
+  "version": "4.36.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": "3.0.0",
-  "buildDate": "2026-01-24T12:20:16.212Z",
+  "buildDate": "2026-01-24T14:49:34.378Z",
   "files": [
     "config.yaml",
     "FLOW.yaml",

package/src/opencode/agents/coder.md

@@ -16,12 +16,12 @@ tools:
   glob: true
   grep: true
   list: true
-  skill: false       # No skill loading - just execute
+  skill: true       # No skill loading - just execute
   question: false    # No questions - execute or fail
   bash: true         # Full bash for tests, builds
   webfetch: false    # No web access
-  todowrite: false   # Subagent - no todo
-  todoread: false
+  todowrite: true   # Not available for subagents (Claude internal tools)
+  todoread: true    # Not available for subagents
   lsp: true          # Code intelligence
 
 # Permissions - fast execution, no prompts

package/src/opencode/agents/dev.md

@@ -48,14 +48,57 @@ permission:
     <r>Find and use `**/project-context.md` and `CLAUDE.md` as source of truth</r>
   </rules>
   
-  <dev-story-workflow hint="When executing dev-story skill">
+  <dev-story-workflow hint="When executing /dev-story command" critical="FOLLOW THIS EXACTLY">
+    <!-- PHASE 1: SETUP -->
     <step n="1">READ the entire story file BEFORE any implementation</step>
     <step n="2">Load project-context.md and CLAUDE.md if available</step>
-    <step n="3">Execute tasks/subtasks IN ORDER as written in story file</step>
-    <step n="4">For each task: follow red-green-refactor cycle</step>
-    <step n="5">Mark task [x] ONLY when implementation AND tests are complete</step>
-    <step n="6">Run full test suite after each task - NEVER proceed with failing tests</step>
+    <step n="3">CREATE TODO LIST from story tasks using todowrite:
+      - Each task becomes a TODO item
+      - Set priority based on task order (first = high)
+      - All tasks start as "pending"
+    </step>
+    <step n="4">Mark story status as "in-progress"</step>
+    
+    <!-- PHASE 2: IMPLEMENTATION LOOP -->
+    <step n="5">FOR EACH TASK in order:
+      a) Update TODO: mark current task as "in_progress"
+      b) Call @coder with specific task instructions:
+         - Include task requirements
+         - Include acceptance criteria
+         - Include relevant file paths
+         - Request: test first, then implement
+      c) VERIFY @coder result:
+         - Check tests exist and pass
+         - Check implementation matches AC
+         - If failed: retry or HALT
+      d) Update TODO: mark task as "completed"
+      e) Update story file: mark task [x]
+      f) Run test suite - HALT if failures
+    </step>
+    
+    <!-- PHASE 3: FINALIZATION -->
+    <step n="6">Run FULL test suite - all tests must pass</step>
+    <step n="7">Update story file: File List, Change Log, Dev Agent Record</step>
+    <step n="8">Clear TODO list (all done)</step>
+    <step n="9">Mark story status as "review"</step>
   </dev-story-workflow>
+  
+  <todo-usage hint="How to use TODO for tracking">
+    <create>
+      todowrite([
+        { id: "story-task-1", content: "Task 1: Create entity", status: "pending", priority: "high" },
+        { id: "story-task-2", content: "Task 2: Add repository", status: "pending", priority: "medium" },
+        ...
+      ])
+    </create>
+    <update-progress>
+      todoread() → get current list
+      todowrite([...list with task.status = "in_progress"])
+    </update-progress>
+    <mark-complete>
+      todowrite([...list with task.status = "completed"])
+    </mark-complete>
+  </todo-usage>
 </activation>
 
 <persona>

package/src/opencode/commands/dev-story.md

@@ -1,6 +1,6 @@
 # /dev-story Command
 
-Implement a story using red-green-refactor cycle.
+Implement a story using red-green-refactor cycle with TODO tracking.
 
 ## Usage
 
@@ -18,16 +18,48 @@ This command invokes the **Dev** agent (Amelia).
 
 ## Process
 
+### Phase 1: Setup
 1. Find or load story file
 2. Load project context (CLAUDE.md, project-context.md)
-3. Mark story as `in-progress`
-4. For each task/subtask:
+3. **Create TODO list from story tasks** (for progress tracking)
+4. Mark story as `in-progress`
+
+### Phase 2: Implementation (for each task)
+5. **Mark task as `in_progress` in TODO**
+6. Delegate to @coder:
    - 🔴 RED: Write failing test
    - 🟢 GREEN: Implement minimal code to pass
    - 🔵 REFACTOR: Improve while keeping tests green
-5. Mark task complete `[x]` only when tests pass
-6. Update story file (File List, Change Log, Dev Agent Record)
-7. Mark story as `review` when all tasks complete
+7. Verify @coder result (tests pass)
+8. **Mark task as `completed` in TODO**
+9. Mark task `[x]` in story file
+
+### Phase 3: Finalization
+10. Run full test suite
+11. Update story file (File List, Change Log, Dev Agent Record)
+12. **Clear TODO** (all tasks done)
+13. Mark story as `review`
+
+## TODO Workflow
+
+```
+┌─────────────────────────────────────────────────┐
+│  @dev reads story → creates TODO:               │
+│  ┌─────────────────────────────────────────┐    │
+│  │ [ ] Task 1: Create User entity          │    │
+│  │ [ ] Task 2: Add repository              │    │
+│  │ [ ] Task 3: Write integration tests     │    │
+│  └─────────────────────────────────────────┘    │
+│                                                 │
+│  For each task:                                 │
+│  1. @dev marks [→] in_progress in TODO          │
+│  2. @dev calls @coder with task details         │
+│  3. @coder implements (no TODO access)          │
+│  4. @dev verifies result                        │
+│  5. @dev marks [✓] completed in TODO            │
+│  6. @dev marks [x] in story file                │
+└─────────────────────────────────────────────────┘
+```
 
 ## Skills Loaded
 

package/src/opencode/config.yaml

@@ -233,7 +233,7 @@ vectorizer:
   auto_index: true
   
   # Debounce time in ms (wait before indexing after file change)
-  debounce_ms: 2000
+  debounce_ms: 1000
   
   # Indexes to maintain
   indexes:

package/src/opencode/plugins/file-indexer.ts

@@ -1,30 +1,51 @@
 import type { Plugin } from "@opencode-ai/plugin"
 import path from "path"
 import fs from "fs/promises"
+import fsSync from "fs"
 
 /**
  * File Indexer Plugin
  * 
  * Automatically manages semantic search indexes:
- * - On session start/resume: freshen existing indexes (update stale files)
+ * - On plugin load (opencode startup): freshen existing indexes
  * - On file edit: queue file for reindexing (debounced)
  * 
  * Configuration in .opencode/config.yaml:
  *   vectorizer:
  *     enabled: true       # Master switch
  *     auto_index: true    # Enable this plugin
- *     debounce_ms: 2000   # Wait time before indexing
+ *     debounce_ms: 1000   # Wait time before indexing
  * 
  * Debug mode: set DEBUG=file-indexer or DEBUG=* to see logs
  */
 
 const DEBUG = process.env.DEBUG?.includes('file-indexer') || process.env.DEBUG === '*'
 
+let logFilePath: string | null = null
+
+// Log to file only
+function logFile(msg: string): void {
+  if (logFilePath) {
+    const timestamp = new Date().toISOString().slice(11, 19)
+    fsSync.appendFileSync(logFilePath, `${timestamp} ${msg}\n`)
+  }
+}
+
+// Log to console AND file
+function log(msg: string): void {
+  console.log(`[file-indexer] ${msg}`)
+  logFile(msg)
+}
+
+function debug(msg: string): void {
+  if (DEBUG) log(msg)
+}
+
 // Default config (used if config.yaml is missing or invalid)
 const DEFAULT_CONFIG = {
   enabled: true,
   auto_index: true,
-  debounce_ms: 2000,
+  debounce_ms: 1000,
   indexes: {
     code: { enabled: true, extensions: ['.js', '.ts', '.jsx', '.tsx', '.py', '.go', '.rs', '.java', '.kt', '.swift', '.c', '.cpp', '.h', '.hpp', '.cs', '.rb', '.php', '.scala', '.clj'] },
     docs: { enabled: true, extensions: ['.md', '.mdx', '.txt', '.rst', '.adoc'] },
@@ -41,12 +62,91 @@ interface VectorizerConfig {
   exclude: string[]
 }
 
-const pendingFiles: Map<string, { indexName: string; timestamp: number }> = new Map()
+// Fun messages based on file count and language
+const FUN_MESSAGES = {
+  en: {
+    indexing: (files: number) => `Indexing ${files} files...`,
+    fun: (files: number, mins: number) => {
+      if (files < 20) return `Quick coffee? ☕`
+      if (files < 100) return `~${mins}min. Stretch break? 🧘`
+      if (files < 500) return `~${mins}min. Make coffee ☕ and relax 🛋️`
+      return `~${mins}min. Go touch grass 🌿 or take a nap 😴`
+    },
+    done: (files: number, duration: string) => {
+      if (files < 20) return `Done! ${files} files in ${duration}. Fast! 🚀`
+      if (files < 100) return `Indexed ${files} files in ${duration}. Let's go! 🎸`
+      return `${files} files in ${duration}. Worth the wait! 🎉`
+    },
+    fresh: () => `Everything's fresh! Nothing to do 😎`,
+    error: (msg: string) => `Oops! ${msg} 😬`
+  },
+  uk: {
+    indexing: (files: number) => `Індексую ${files} файлів...`,
+    fun: (files: number, mins: number) => {
+      if (files < 20) return `Швидка кава? ☕`
+      if (files < 100) return `~${mins}хв. Розімнись! 🧘`
+      if (files < 500) return `~${mins}хв. Зроби каву ☕ і відпочинь 🛋️`
+      return `~${mins}хв. Йди погуляй 🌿 або поспи 😴`
+    },
+    done: (files: number, duration: string) => {
+      if (files < 20) return `Готово! ${files} файлів за ${duration}. Швидко! 🚀`
+      if (files < 100) return `${files} файлів за ${duration}. Поїхали! 🎸`
+      return `${files} файлів за ${duration}. Варто було чекати! 🎉`
+    },
+    fresh: () => `Все свіже! Нічого робити 😎`,
+    error: (msg: string) => `Ой! ${msg} 😬`
+  },
+  ru: {
+    indexing: (files: number) => `Индексирую ${files} файлов...`,
+    fun: (files: number, mins: number) => {
+      if (files < 20) return `Кофе? ☕`
+      if (files < 100) return `~${mins}мин. Разомнись! 🧘`
+      if (files < 500) return `~${mins}мин. Сделай кофе ☕ и отдохни 🛋️`
+      return `~${mins}мин. Иди погуляй 🌿 или поспи 😴`
+    },
+    done: (files: number, duration: string) => {
+      if (files < 20) return `Готово! ${files} файлов за ${duration}. Быстро! 🚀`
+      if (files < 100) return `${files} файлов за ${duration}. Поехали! 🎸`
+      return `${files} файлов за ${duration}. Стоило подождать! 🎉`
+    },
+    fresh: () => `Всё свежее! Делать нечего 😎`,
+    error: (msg: string) => `Ой! ${msg} 😬`
+  }
+}
 
-function debug(msg: string): void {
-  if (DEBUG) console.log(`[file-indexer] ${msg}`)
+type Lang = keyof typeof FUN_MESSAGES
+
+async function getLanguage(projectRoot: string): Promise<Lang> {
+  try {
+    const configPath = path.join(projectRoot, ".opencode", "config.yaml")
+    const content = await fs.readFile(configPath, 'utf8')
+    const match = content.match(/communication_language:\s*["']?(\w+)["']?/i)
+    const lang = match?.[1]?.toLowerCase()
+    if (lang === 'ukrainian' || lang === 'uk') return 'uk'
+    if (lang === 'russian' || lang === 'ru') return 'ru'
+    return 'en'
+  } catch {
+    return 'en'
+  }
 }
 
+function estimateTime(fileCount: number): number {
+  // Model loading: ~30 sec, then ~0.5 sec per file
+  const modelLoadTime = 30 // seconds
+  const perFileTime = 0.5 // seconds
+  const totalSeconds = modelLoadTime + (fileCount * perFileTime)
+  return Math.ceil(totalSeconds / 60) // minutes
+}
+
+function formatDuration(seconds: number): string {
+  if (seconds < 60) return `${Math.round(seconds)}s`
+  const mins = Math.floor(seconds / 60)
+  const secs = Math.round(seconds % 60)
+  return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`
+}
+
+const pendingFiles: Map<string, { indexName: string; timestamp: number }> = new Map()
+
 async function loadConfig(projectRoot: string): Promise<VectorizerConfig> {
   try {
     const configPath = path.join(projectRoot, ".opencode", "config.yaml")
@@ -119,46 +219,120 @@ async function hasIndex(projectRoot: string, indexName: string): Promise<boolean
   }
 }
 
+interface IndexResult {
+  totalFiles: number
+  elapsedSeconds: number
+  action: 'created' | 'rebuilt' | 'freshened' | 'skipped'
+}
+
 /**
  * Ensure index exists and is fresh on session start
+ * Creates index if missing, freshens if exists
  */
-async function ensureIndexOnSessionStart(projectRoot: string, config: VectorizerConfig): Promise<void> {
+async function ensureIndexOnSessionStart(
+  projectRoot: string, 
+  config: VectorizerConfig,
+  onStart?: (totalFiles: number, estimatedMins: number) => void
+): Promise<IndexResult> {
+  let totalFiles = 0
+  let elapsedSeconds = 0
+  let action: IndexResult['action'] = 'skipped'
+  
   if (!await isVectorizerInstalled(projectRoot)) {
-    debug('Session start: vectorizer not installed, skipping')
-    return
+    log(`Vectorizer not installed - run: npx @comfanion/workflow vectorizer install`)
+    return { totalFiles: 0, elapsedSeconds: 0, action: 'skipped' }
   }
   
   try {
     const vectorizerModule = path.join(projectRoot, ".opencode", "vectorizer", "index.js")
     const { CodebaseIndexer } = await import(`file://${vectorizerModule}`)
+    const overallStart = Date.now()
+    
+    // First pass - count files and check health
+    let needsWork = false
+    let totalExpectedFiles = 0
     
-    // Check each enabled index
     for (const [indexName, indexConfig] of Object.entries(config.indexes)) {
       if (!indexConfig.enabled) continue
-      
+      const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
       const indexExists = await hasIndex(projectRoot, indexName)
       
       if (!indexExists) {
-        // No index - need full indexing (but don't block session, just log)
-        debug(`Session start: index "${indexName}" not found, run: npx @comfanion/workflow index --index ${indexName}`)
-        continue
+        const health = await indexer.checkHealth(config.exclude)
+        totalExpectedFiles += health.expectedCount
+        needsWork = true
+      } else {
+        const health = await indexer.checkHealth(config.exclude)
+        if (health.needsReindex) {
+          totalExpectedFiles += health.expectedCount
+          needsWork = true
+        }
       }
+      await indexer.unloadModel()
+    }
+    
+    // Notify about work to do
+    if (needsWork && onStart) {
+      onStart(totalExpectedFiles, estimateTime(totalExpectedFiles))
+    }
+    
+    // Second pass - do the actual work
+    for (const [indexName, indexConfig] of Object.entries(config.indexes)) {
+      if (!indexConfig.enabled) continue
+      
+      const indexExists = await hasIndex(projectRoot, indexName)
+      const startTime = Date.now()
       
-      // Index exists - freshen it (update stale files)
-      debug(`Session start: freshening index "${indexName}"...`)
       const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
-      const stats = await indexer.freshen()
       
-      if (stats.updated > 0 || stats.deleted > 0) {
-        debug(`Session start: ${indexName} - updated ${stats.updated}, deleted ${stats.deleted}`)
+      if (!indexExists) {
+        log(`Creating "${indexName}" index...`)
+        const stats = await indexer.indexAll((indexed: number, total: number, file: string) => {
+          if (indexed % 10 === 0 || indexed === total) {
+            logFile(`"${indexName}": ${indexed}/${total} - ${file}`)
+          }
+        }, config.exclude)
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+        log(`"${indexName}": done ${stats.indexed} files (${elapsed}s)`)
+        totalFiles += stats.indexed
+        action = 'created'
       } else {
-        debug(`Session start: ${indexName} - index is fresh`)
+        const health = await indexer.checkHealth(config.exclude)
+        
+        if (health.needsReindex) {
+          log(`Rebuilding "${indexName}" (${health.reason}: ${health.currentCount} vs ${health.expectedCount} files)...`)
+          const stats = await indexer.indexAll((indexed: number, total: number, file: string) => {
+            if (indexed % 10 === 0 || indexed === total) {
+              logFile(`"${indexName}": ${indexed}/${total} - ${file}`)
+            }
+          }, config.exclude)
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+          log(`"${indexName}": rebuilt ${stats.indexed} files (${elapsed}s)`)
+          totalFiles += stats.indexed
+          action = 'rebuilt'
+        } else {
+          log(`Freshening "${indexName}"...`)
+          const stats = await indexer.freshen()
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+          
+          if (stats.updated > 0 || stats.deleted > 0) {
+            log(`"${indexName}": +${stats.updated} -${stats.deleted} (${elapsed}s)`)
+            action = 'freshened'
+          } else {
+            log(`"${indexName}": fresh (${elapsed}s)`)
+          }
+        }
       }
       
       await indexer.unloadModel()
     }
+    
+    elapsedSeconds = (Date.now() - overallStart) / 1000
+    log(`Indexes ready!`)
+    return { totalFiles, elapsedSeconds, action }
   } catch (e) {
-    debug(`Session start error: ${(e as Error).message}`)
+    log(`Index error: ${(e as Error).message}`)
+    throw e
   }
 }
 
@@ -209,20 +383,63 @@ async function processPendingFiles(projectRoot: string, config: VectorizerConfig
   }
 }
 
-export const FileIndexerPlugin: Plugin = async ({ directory }) => {
+export const FileIndexerPlugin: Plugin = async ({ directory, client }) => {
   let processingTimeout: NodeJS.Timeout | null = null
   let config = await loadConfig(directory)
   
+  // Toast helper
+  const toast = async (message: string, variant: 'info' | 'success' | 'error' = 'info') => {
+    try {
+      await client?.tui?.showToast?.({ body: { message, variant } })
+    } catch {}
+  }
+  
+  // Always log plugin load
+  log(`Plugin loaded for: ${path.basename(directory)}`)
+  
   // Check if plugin should be active
   if (!config.enabled || !config.auto_index) {
-    debug(`Plugin disabled (enabled: ${config.enabled}, auto_index: ${config.auto_index})`)
+    log(`Plugin DISABLED (enabled: ${config.enabled}, auto_index: ${config.auto_index})`)
     return {
       event: async () => {}, // No-op
     }
   }
   
-  debug(`Plugin loaded for: ${directory}`)
-  debug(`Config: debounce=${config.debounce_ms}ms, exclude=${config.exclude.length} patterns`)
+  // Setup log file
+  logFilePath = path.join(directory, '.opencode', 'indexer.log')
+  fsSync.writeFileSync(logFilePath, '') // Clear old log
+  
+  log(`Plugin ACTIVE`)
+  
+  // Get language for fun messages
+  const lang = await getLanguage(directory)
+  const messages = FUN_MESSAGES[lang]
+  
+  // Run indexing async (non-blocking) with toast notifications
+  // Small delay to let TUI initialize
+  setTimeout(async () => {
+    try {
+      const result = await ensureIndexOnSessionStart(
+        directory, 
+        config,
+        // onStart callback - show 2 toasts
+        async (totalFiles, estimatedMins) => {
+          await toast(messages.indexing(totalFiles), 'info')
+          setTimeout(() => toast(messages.fun(totalFiles, estimatedMins), 'info'), 1500)
+        }
+      )
+      
+      // Show result
+      if (result.action === 'skipped') {
+        toast(messages.fresh(), 'success')
+      } else {
+        const duration = formatDuration(result.elapsedSeconds)
+        toast(messages.done(result.totalFiles, duration), 'success')
+      }
+    } catch (e: any) {
+      toast(messages.error(e.message), 'error')
+    }
+  }, 1000)
   
   function queueFileForIndexing(filePath: string): void {
     const relativePath = path.relative(directory, filePath)
@@ -250,35 +467,15 @@ export const FileIndexerPlugin: Plugin = async ({ directory }) => {
     }, config.debounce_ms + 100)
   }
 
-  // Track if we've already freshened this session
-  let sessionFreshened = false
-  
+  // Event handler for file changes (if events start working in future)
   return {
-    event: async (ctx) => {
-      const event = ctx.event
-      
-      // Freshen index on session start/resume
-      if ((event.type === "session.started" || event.type === "session.resumed") && !sessionFreshened) {
-        sessionFreshened = true
-        debug(`${event.type}: checking indexes...`)
-        // Run async, don't block
-        ensureIndexOnSessionStart(directory, config).catch(e => debug(`Error: ${e.message}`))
-      }
-      
-      if (event.type === "file.edited") {
-        const props = (event as any).properties || {}
-        const filePath = props.file || props.path || props.filePath
-        if (filePath) {
-          debug(`file.edited: ${filePath}`)
-          queueFileForIndexing(filePath)
-        }
-      }
-      
-      if (event.type === "file.watcher.updated") {
+    event: async ({ event }) => {
+      // File edit events - queue for reindexing
+      if (event.type === "file.edited" || event.type === "file.watcher.updated") {
         const props = (event as any).properties || {}
         const filePath = props.file || props.path || props.filePath
         if (filePath) {
-          debug(`file.watcher.updated: ${filePath}`)
+          debug(`${event.type}: ${filePath}`)
           queueFileForIndexing(filePath)
         }
       }