@comfanion/workflow 4.35.0 → 4.36.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.35.0",
+  "version": "4.36.2",
   "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-24T13:22:48.754Z",
+  "buildDate": "2026-01-24T14:53:32.419Z",
   "files": [
     "config.yaml",
     "FLOW.yaml",

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

@@ -1,25 +1,46 @@
 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: 100   # 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,
@@ -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)
         }
       }

package/src/vectorizer/index.js

@@ -22,18 +22,22 @@ if (!DEBUG) {
 const INDEX_PRESETS = {
   code: {
     pattern: '**/*.{js,ts,jsx,tsx,mjs,cjs,py,go,rs,java,kt,swift,c,cpp,h,hpp,cs,rb,php,scala,clj}',
-    description: 'Source code files'
+    ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**', '**/.opencode/**', '**/docs/**', '**/vendor/**', '**/__pycache__/**'],
+    description: 'Source code files (excludes docs, vendor, node_modules)'
   },
   docs: {
-    pattern: '**/*.{md,mdx,txt,rst,adoc}',
-    description: 'Documentation files'
+    pattern: 'docs/**/*.{md,mdx,txt,rst,adoc}',
+    ignore: [],
+    description: 'Documentation in docs/ folder'
   },
   config: {
     pattern: '**/*.{yaml,yml,json,toml,ini,env,xml}',
+    ignore: ['**/node_modules/**', '**/.git/**', '**/.opencode/**'],
     description: 'Configuration files'
   },
   all: {
     pattern: '**/*.{js,ts,jsx,tsx,mjs,cjs,py,go,rs,java,kt,swift,c,cpp,h,hpp,cs,rb,php,scala,clj,md,mdx,txt,rst,adoc,yaml,yml,json,toml}',
+    ignore: ['**/node_modules/**', '**/.git/**', '**/.opencode/**'],
     description: 'All supported files'
   }
 };
@@ -208,6 +212,43 @@ class CodebaseIndexer {
     return results;
   }
 
+  /**
+   * Check if index needs full reindex (files don't match current patterns)
+   * @param {string[]} extraIgnore - Additional patterns to ignore
+   * Returns { needsReindex, reason, currentCount, expectedCount }
+   */
+  async checkHealth(extraIgnore = []) {
+    const { glob } = await import('glob');
+    const preset = INDEX_PRESETS[this.indexName] || INDEX_PRESETS.code;
+    
+    // Combine preset ignore with extra ignore patterns
+    const ignore = [...(preset.ignore || []), ...extraIgnore.map(p => `**/${p}/**`)];
+    
+    const expectedFiles = await glob(preset.pattern, { 
+      cwd: this.root, 
+      nodir: true,
+      ignore
+    });
+    
+    const indexedFiles = Object.keys(this.hashes);
+    const currentCount = indexedFiles.length;
+    const expectedCount = expectedFiles.length;
+    
+    // Check if counts differ significantly (>20% difference or index is empty)
+    const diff = Math.abs(currentCount - expectedCount);
+    const threshold = Math.max(5, expectedCount * 0.2); // 20% or at least 5 files
+    
+    if (currentCount === 0 && expectedCount > 0) {
+      return { needsReindex: true, reason: 'empty', currentCount, expectedCount };
+    }
+    
+    if (diff > threshold) {
+      return { needsReindex: true, reason: 'mismatch', currentCount, expectedCount };
+    }
+    
+    return { needsReindex: false, reason: 'ok', currentCount, expectedCount };
+  }
+
   /**
    * Freshen index - check for stale files and reindex only changed ones
    * Returns { checked, updated, deleted } counts
@@ -246,6 +287,46 @@ class CodebaseIndexer {
     return { checked, updated, deleted };
   }
 
+  /**
+   * Index all files matching the preset pattern
+   * @param {function} onProgress - Optional callback(indexed, total, currentFile)
+   * @param {string[]} extraIgnore - Additional patterns to ignore
+   * Returns { indexed, skipped } counts
+   */
+  async indexAll(onProgress = null, extraIgnore = []) {
+    const { glob } = await import('glob');
+    const preset = INDEX_PRESETS[this.indexName] || INDEX_PRESETS.code;
+    
+    // Combine preset ignore with extra ignore patterns
+    const ignore = [...(preset.ignore || []), ...extraIgnore.map(p => `**/${p}/**`)];
+    
+    const files = await glob(preset.pattern, { 
+      cwd: this.root, 
+      nodir: true,
+      ignore
+    });
+    
+    let indexed = 0;
+    let skipped = 0;
+    
+    for (const relPath of files) {
+      const filePath = path.join(this.root, relPath);
+      try {
+        const wasIndexed = await this.indexFile(filePath);
+        if (wasIndexed) {
+          indexed++;
+          if (onProgress) onProgress(indexed, files.length, relPath);
+        } else {
+          skipped++;
+        }
+      } catch (e) {
+        skipped++;
+      }
+    }
+    
+    return { indexed, skipped, total: files.length };
+  }
+
   /**
    * Index a single file by path (convenience method)
    */