@comfanion/workflow 4.28.0 → 4.31.0

package/bin/cli.js

@@ -101,6 +101,8 @@ program
       jira_project: 'PROJ',
       create_repo_structure: false,
       install_vectorizer: false,
+      vectorizer_enabled: true,
+      vectorizer_auto_index: true,
       project_name: path.basename(process.cwd())
     };
     
@@ -120,12 +122,18 @@ program
           const jiraUrlMatch = existingContent.match(/base_url:\s*"([^"]+)"/);
           const jiraProjMatch = existingContent.match(/project_key:\s*"([^"]+)"/);
           
+          // Parse vectorizer settings
+          const vectorizerEnabledMatch = existingContent.match(/vectorizer:[\s\S]*?enabled:\s*(true|false)/);
+          const vectorizerAutoIndexMatch = existingContent.match(/vectorizer:[\s\S]*?auto_index:\s*(true|false)/);
+          
           if (nameMatch) config.user_name = nameMatch[1];
           if (langMatch) config.communication_language = langMatch[1];
           if (methMatch) config.methodology = methMatch[1];
           if (jiraMatch) config.jira_enabled = jiraMatch[1] === 'true';
           if (jiraUrlMatch) config.jira_url = jiraUrlMatch[1];
           if (jiraProjMatch) config.jira_project = jiraProjMatch[1];
+          if (vectorizerEnabledMatch) config.vectorizer_enabled = vectorizerEnabledMatch[1] === 'true';
+          if (vectorizerAutoIndexMatch) config.vectorizer_auto_index = vectorizerAutoIndexMatch[1] === 'true';
           
           isUpdate = true;
         } catch (e) {
@@ -217,8 +225,15 @@ program
         {
           type: 'confirm',
           name: 'install_vectorizer',
-          message: 'Install vectorizer & caching? (semantic code search, ~100MB)',
+          message: 'Install vectorizer? (semantic code search, ~100MB)',
           default: false
+        },
+        {
+          type: 'confirm',
+          name: 'vectorizer_auto_index',
+          message: 'Enable auto-indexing? (reindex files on save)',
+          when: (answers) => answers.install_vectorizer,
+          default: true
         }
       ]);
       
@@ -322,6 +337,13 @@ program
           .replace(/project_key: ".*"/, `project_key: "${config.jira_project}"`);
       }
       
+      // Vectorizer config
+      configContent = configContent
+        .replace(/(vectorizer:\s*\n\s+# Enable\/disable.*\n\s+enabled:)\s*(true|false)/, 
+          `$1 ${config.vectorizer_enabled}`)
+        .replace(/(# Auto-index files.*\n\s+auto_index:)\s*(true|false)/, 
+          `$1 ${config.vectorizer_auto_index}`);
+      
       await fs.writeFile(configPath, configContent);
       
       // Create docs structure (always)
@@ -391,7 +413,8 @@ program
         console.log(chalk.green('✅ Plugin dependencies installed'));
       } catch (e) {
         spinner.succeed(chalk.green('OpenCode Workflow initialized!'));
-        console.log(chalk.yellow('⚠️  Plugin dependencies: run `cd .opencode && bun install`'));
+        console.log(chalk.yellow(`⚠️  Plugin dependencies failed: ${e.message}`));
+        console.log(chalk.gray('   Run manually: cd .opencode && bun install'));
       }
 
       // Show what was preserved
@@ -549,20 +572,41 @@ program
         await fs.move(tempVectors, path.join(targetDir, 'vectors'), { overwrite: true });
       }
       
-      // Restore user's config.yaml
+      // Restore user's config.yaml with new sections if missing
       spinner.text = 'Restoring config.yaml...';
-      await fs.writeFile(configPath, configBackup);
+      let mergedConfig = configBackup;
+      
+      // Add vectorizer section if missing
+      if (!mergedConfig.includes('vectorizer:')) {
+        const newConfigPath = path.join(targetDir, 'config.yaml');
+        const newConfig = await fs.readFile(newConfigPath, 'utf8');
+        const vectorizerMatch = newConfig.match(/(# =+\n# VECTORIZER[\s\S]*?)(?=# =+\n# [A-Z])/);
+        if (vectorizerMatch) {
+          // Insert before LSP section or at end
+          const insertPoint = mergedConfig.indexOf('# =============================================================================\n# LSP');
+          if (insertPoint > 0) {
+            mergedConfig = mergedConfig.slice(0, insertPoint) + vectorizerMatch[1] + mergedConfig.slice(insertPoint);
+          } else {
+            mergedConfig += '\n' + vectorizerMatch[1];
+          }
+          console.log(chalk.green('  ✅ Added new vectorizer configuration section'));
+        }
+      }
+      
+      await fs.writeFile(configPath, mergedConfig);
       
       // Install plugin dependencies
       spinner.text = 'Installing plugin dependencies...';
+      let pluginDepsInstalled = false;
       try {
         execSync('bun install', { 
           cwd: targetDir, 
           stdio: 'pipe',
           timeout: 60000
         });
+        pluginDepsInstalled = true;
       } catch (e) {
-        // Ignore errors, will show warning below
+        // Will show warning below
       }
       
       spinner.succeed(chalk.green('OpenCode Workflow updated!'));
@@ -573,7 +617,11 @@ program
       }
       
       console.log(chalk.green('✅ Your config.yaml was preserved.'));
-      console.log(chalk.green('✅ Plugin dependencies installed.'));
+      if (pluginDepsInstalled) {
+        console.log(chalk.green('✅ Plugin dependencies installed.'));
+      } else {
+        console.log(chalk.yellow('⚠️  Plugin deps: run `cd .opencode && bun install`'));
+      }
       if (hasVectorizer) {
         console.log(chalk.green('✅ Vectorizer updated (node_modules preserved).'));
       }
@@ -678,8 +726,25 @@ program
     const vectorizerInstalled = await fs.pathExists(path.join(process.cwd(), '.opencode', 'vectorizer', 'node_modules'));
     const vectorsExist = await fs.pathExists(path.join(process.cwd(), '.opencode', 'vectors', 'hashes.json'));
     
+    // Check vectorizer config
+    let vectorizerEnabled = true;
+    let autoIndexEnabled = true;
+    try {
+      const vecConfigContent = await fs.readFile(path.join(process.cwd(), '.opencode/config.yaml'), 'utf8');
+      const vecEnabledMatch = vecConfigContent.match(/vectorizer:[\s\S]*?enabled:\s*(true|false)/);
+      const autoIndexMatch = vecConfigContent.match(/vectorizer:[\s\S]*?auto_index:\s*(true|false)/);
+      if (vecEnabledMatch) vectorizerEnabled = vecEnabledMatch[1] === 'true';
+      if (autoIndexMatch) autoIndexEnabled = autoIndexMatch[1] === 'true';
+    } catch {}
+    
     if (vectorizerInstalled) {
       console.log(chalk.green('  ✅ Installed'));
+      console.log(vectorizerEnabled 
+        ? chalk.green('  ✅ Enabled in config')
+        : chalk.yellow('  ⚠️  Disabled in config'));
+      console.log(autoIndexEnabled
+        ? chalk.green('  ✅ Auto-index: ON')
+        : chalk.gray('  ○  Auto-index: OFF'));
       if (vectorsExist) {
         try {
           const hashes = await fs.readJSON(path.join(process.cwd(), '.opencode', 'vectors', 'hashes.json'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.28.0",
+  "version": "4.31.0",
   "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-24T11:37:39.734Z",
+  "buildDate": "2026-01-24T12:03:24.833Z",
   "files": [
     "config.yaml",
     "FLOW.yaml",

package/src/opencode/agents/crawler.md

@@ -63,21 +63,21 @@ permission:
 **After `codeindex list` shows indexes exist, you MUST immediately call:**
 
 ```
-codesearch({ query: "category mapping", index: "code" })
+search({ query: "category mapping", index: "code" })
 ```
 
-**DO NOT call grep or glob until codesearch is done!**
+**DO NOT call grep or glob until search is done!**
 
 | Step | Action | Tool |
 |------|--------|------|
 | 1 | Check indexes | `codeindex({ action: "list" })` |
-| 2 | **SEARCH** | `codesearch({ query: "...", index: "code" })` ← DO THIS! |
-| 3 | Read results | `read` top 3-5 files from codesearch |
+| 2 | **SEARCH** | `search({ query: "...", index: "code" })` ← DO THIS! |
+| 3 | Read results | `read` top 3-5 files from search |
 | 4 | Only if needed | `grep` for exact string match |
 
 ```
 ❌ WRONG: codeindex list → grep → glob → 100 matches → slow
-✅ RIGHT: codeindex list → codesearch → 5 files → fast
+✅ RIGHT: codeindex list → search → 5 files → fast
 ```
 
 ---
@@ -85,20 +85,20 @@ codesearch({ query: "category mapping", index: "code" })
 <agent id="crawler" name="Scout" title="Codebase Crawler" icon="🔎">
 
 <activation critical="MANDATORY">
-  <!-- ⛔ CRITICAL: After codeindex list, IMMEDIATELY call codesearch! NOT grep! -->
+  <!-- ⛔ CRITICAL: After codeindex list, IMMEDIATELY call search! NOT grep! -->
   
   <step n="1">Receive exploration request</step>
   <step n="2">codeindex({ action: "list" }) → Check indexes</step>
-  <step n="3" critical="YES">⚠️ IMMEDIATELY: codesearch({ query: "...", index: "code" })</step>
-  <step n="4">Read codesearch results (top 3-5 files)</step>
-  <step n="5">ONLY if codesearch insufficient → grep for exact matches</step>
+  <step n="3" critical="YES">⚠️ IMMEDIATELY: search({ query: "...", index: "code" })</step>
+  <step n="4">Read search results (top 3-5 files)</step>
+  <step n="5">ONLY if search insufficient → grep for exact matches</step>
   <step n="6">Return findings with file:line</step>
   
   <stop-and-think>
     After step 2, ASK YOURSELF:
     - Did codeindex show indexes exist? → YES
-    - Did I call codesearch yet? → If NO, call it NOW!
-    - Am I about to call grep/glob? → STOP! Call codesearch first!
+    - Did I call search yet? → If NO, call it NOW!
+    - Am I about to call grep/glob? → STOP! Call search first!
   </stop-and-think>
 
   <rules>
@@ -112,7 +112,7 @@ codesearch({ query: "category mapping", index: "code" })
   
   <anti-pattern>
     ❌ WRONG: codeindex list → grep → glob → read 20 files
-    ✅ RIGHT: codeindex list → codesearch → read 3-5 files
+    ✅ RIGHT: codeindex list → search → read 3-5 files
   </anti-pattern>
 </activation>
 
@@ -179,21 +179,21 @@ codesearch({ query: "category mapping", index: "code" })
   </prefer-lsp-when>
 </lsp-exploration>
 
-<codesearch-exploration hint="MANDATORY - USE SEMANTIC SEARCH FIRST">
+<search-exploration hint="MANDATORY - USE SEMANTIC SEARCH FIRST">
   <critical priority="HIGHEST">
-    ⚠️ DO NOT USE grep/glob UNTIL you've tried codesearch!
+    ⚠️ DO NOT USE grep/glob UNTIL you've tried search!
     
     WRONG: codeindex({ action: "list" }) → see indexes → grep anyway
-    RIGHT: codeindex({ action: "list" }) → see indexes → codesearch({ query: "..." })
+    RIGHT: codeindex({ action: "list" }) → see indexes → search({ query: "..." })
     
-    codesearch returns 5-10 RELEVANT files
+    search returns 5-10 RELEVANT files
     grep returns 100+ UNFILTERED matches - SLOW!
   </critical>
   
   <mandatory-workflow>
     STEP 1: codeindex({ action: "list" }) → Check indexes
-    STEP 2: IF indexes exist → codesearch({ query: "your concept" }) → READ results
-    STEP 3: ONLY if codesearch fails → fall back to grep
+    STEP 2: IF indexes exist → search({ query: "your concept" }) → READ results
+    STEP 3: ONLY if search fails → fall back to grep
     
     NEVER skip step 2!
   </mandatory-workflow>
@@ -205,10 +205,10 @@ codesearch({ query: "category mapping", index: "code" })
   </indexes>
   
   <commands>
-    <cmd>codesearch({ query: "concept", index: "code" }) → Search source code</cmd>
-    <cmd>codesearch({ query: "how to deploy", index: "docs" }) → Search documentation</cmd>
-    <cmd>codesearch({ query: "database settings", index: "config" }) → Search configs</cmd>
-    <cmd>codesearch({ query: "error handling", searchAll: true }) → Search ALL indexes</cmd>
+    <cmd>search({ query: "concept", index: "code" }) → Search source code</cmd>
+    <cmd>search({ query: "how to deploy", index: "docs" }) → Search documentation</cmd>
+    <cmd>search({ query: "database settings", index: "config" }) → Search configs</cmd>
+    <cmd>search({ query: "error handling", searchAll: true }) → Search ALL indexes</cmd>
     <cmd>codeindex({ action: "list" }) → List all indexes with stats</cmd>
     <cmd>codeindex({ action: "status", index: "code" }) → Check specific index</cmd>
   </commands>
@@ -237,12 +237,12 @@ codesearch({ query: "category mapping", index: "code" })
     </use>
   </which-index-to-use>
   
-  <prefer-codesearch-when>
+  <prefer-search-when>
     - Looking for code by CONCEPT not exact name: "user authentication flow"
     - Finding SIMILAR patterns: "repository implementations"
     - Exploring unfamiliar codebase: "how errors are handled"
     - Need context around a feature: "payment processing"
-  </prefer-codesearch-when>
+  </prefer-search-when>
   
   <use-grep-when>
     - Know exact string to find: "func CreateUser"
@@ -255,10 +255,10 @@ codesearch({ query: "category mapping", index: "code" })
     1. codeindex({ action: "list" }) → See what indexes exist
     
     2. IMMEDIATELY after seeing indexes, USE THEM:
-       codesearch({ query: "category mapping logic", index: "code" })
+       search({ query: "category mapping logic", index: "code" })
        → Returns 5-10 relevant files with code snippets!
        
-    3. Read the codesearch results (top 3-5 files)
+    3. Read the search results (top 3-5 files)
        → You now have the answer. Done!
        
     4. ONLY use grep/glob for:
@@ -271,14 +271,14 @@ codesearch({ query: "category mapping", index: "code" })
        - Fall back to grep as last resort
        
     ⚠️ ANTI-PATTERN: codeindex list → grep → glob → read 20 files = WRONG!
-    ✅ CORRECT:      codeindex list → codesearch → read 5 files = FAST!
+    ✅ CORRECT:      codeindex list → search → read 5 files = FAST!
   </exploration-strategy>
   
   <efficiency-comparison>
     BAD:  grep "category.*mapping" → 100 matches → read 20 files → slow!
-    GOOD: codesearch({ query: "category mapping logic" }) → 5 files → fast!
+    GOOD: search({ query: "category mapping logic" }) → 5 files → fast!
   </efficiency-comparison>
-</codesearch-exploration>
+</search-exploration>
 
 </agent>
 

package/src/opencode/config.yaml

@@ -222,6 +222,42 @@ testarch:
   use_playwright: false
   use_mcp_enhancements: true
 
+# =============================================================================
+# VECTORIZER (Semantic Code Search)
+# =============================================================================
+vectorizer:
+  # Enable/disable vectorizer functionality
+  enabled: true
+  
+  # Auto-index files when they change (requires file-indexer plugin)
+  auto_index: true
+  
+  # Debounce time in ms (wait before indexing after file change)
+  debounce_ms: 2000
+  
+  # Indexes to maintain
+  indexes:
+    code:
+      enabled: true
+      extensions: ['.js', '.ts', '.jsx', '.tsx', '.py', '.go', '.rs', '.java']
+    docs:
+      enabled: true
+      extensions: ['.md', '.mdx', '.txt', '.rst']
+    config:
+      enabled: false  # Usually not needed
+      extensions: ['.yaml', '.yml', '.json', '.toml']
+  
+  # Directories to exclude from indexing
+  exclude:
+    - node_modules
+    - .git
+    - dist
+    - build
+    - .opencode/vectors
+    - .opencode/vectorizer
+    - vendor
+    - __pycache__
+
 # =============================================================================
 # LSP (Language Server Protocol) - Code Intelligence
 # =============================================================================

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

@@ -7,31 +7,98 @@ import fs from "fs/promises"
  * 
  * Automatically reindexes changed files for semantic search.
  * 
- * Listens to:
- * - file.edited - when agent edits a file
- * - file.watcher.updated - when file changes on disk
- * - tool.execute.after - after Edit/Write tool executes
+ * Configuration in .opencode/config.yaml:
+ *   vectorizer:
+ *     enabled: true       # Master switch
+ *     auto_index: true    # Enable this plugin
+ *     debounce_ms: 2000   # Wait time before indexing
+ * 
+ * Debug mode: set DEBUG=file-indexer or DEBUG=* to see logs
  */
 
-const INDEX_EXTENSIONS: Record<string, string[]> = {
-  code: ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', '.py', '.go', '.rs', '.java', '.kt', '.swift', '.c', '.cpp', '.h', '.hpp', '.cs', '.rb', '.php', '.scala', '.clj'],
-  docs: ['.md', '.mdx', '.txt', '.rst', '.adoc'],
-  config: ['.yaml', '.yml', '.json', '.toml', '.ini', '.xml'],
+const DEBUG = process.env.DEBUG?.includes('file-indexer') || process.env.DEBUG === '*'
+
+// Default config (used if config.yaml is missing or invalid)
+const DEFAULT_CONFIG = {
+  enabled: true,
+  auto_index: true,
+  debounce_ms: 2000,
+  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'] },
+    config: { enabled: false, extensions: ['.yaml', '.yml', '.json', '.toml', '.ini', '.xml'] },
+  },
+  exclude: ['node_modules', '.git', 'dist', 'build', '.opencode/vectors', '.opencode/vectorizer', 'vendor', '__pycache__'],
+}
+
+interface VectorizerConfig {
+  enabled: boolean
+  auto_index: boolean
+  debounce_ms: number
+  indexes: Record<string, { enabled: boolean; extensions: string[] }>
+  exclude: string[]
 }
 
 const pendingFiles: Map<string, { indexName: string; timestamp: number }> = new Map()
-const DEBOUNCE_MS = 2000
 
-function getIndexForFile(filePath: string): string | null {
+function debug(msg: string): void {
+  if (DEBUG) console.log(`[file-indexer] ${msg}`)
+}
+
+async function loadConfig(projectRoot: string): Promise<VectorizerConfig> {
+  try {
+    const configPath = path.join(projectRoot, ".opencode", "config.yaml")
+    const content = await fs.readFile(configPath, 'utf8')
+    
+    // Simple YAML parsing for vectorizer section
+    const vectorizerMatch = content.match(/vectorizer:\s*\n([\s\S]*?)(?=\n[a-z_]+:|$)/i)
+    if (!vectorizerMatch) {
+      debug('No vectorizer section in config.yaml, using defaults')
+      return DEFAULT_CONFIG
+    }
+    
+    const section = vectorizerMatch[1]
+    
+    // Parse enabled
+    const enabledMatch = section.match(/^\s+enabled:\s*(true|false)/m)
+    const enabled = enabledMatch ? enabledMatch[1] === 'true' : DEFAULT_CONFIG.enabled
+    
+    // Parse auto_index
+    const autoIndexMatch = section.match(/^\s+auto_index:\s*(true|false)/m)
+    const auto_index = autoIndexMatch ? autoIndexMatch[1] === 'true' : DEFAULT_CONFIG.auto_index
+    
+    // Parse debounce_ms
+    const debounceMatch = section.match(/^\s+debounce_ms:\s*(\d+)/m)
+    const debounce_ms = debounceMatch ? parseInt(debounceMatch[1]) : DEFAULT_CONFIG.debounce_ms
+    
+    // Parse exclude array
+    const excludeMatch = section.match(/exclude:\s*\n((?:\s+-\s+.+\n?)+)/m)
+    let exclude = DEFAULT_CONFIG.exclude
+    if (excludeMatch) {
+      exclude = excludeMatch[1].match(/-\s+(.+)/g)?.map(m => m.replace(/^-\s+/, '').trim()) || DEFAULT_CONFIG.exclude
+    }
+    
+    return { enabled, auto_index, debounce_ms, indexes: DEFAULT_CONFIG.indexes, exclude }
+  } catch (e) {
+    debug(`Failed to load config: ${(e as Error).message}`)
+    return DEFAULT_CONFIG
+  }
+}
+
+function getIndexForFile(filePath: string, config: VectorizerConfig): string | null {
   const ext = path.extname(filePath).toLowerCase()
-  for (const [indexName, extensions] of Object.entries(INDEX_EXTENSIONS)) {
-    if (extensions.includes(ext)) {
+  for (const [indexName, indexConfig] of Object.entries(config.indexes)) {
+    if (indexConfig.enabled && indexConfig.extensions.includes(ext)) {
       return indexName
     }
   }
   return null
 }
 
+function isExcluded(relativePath: string, config: VectorizerConfig): boolean {
+  return config.exclude.some(pattern => relativePath.startsWith(pattern))
+}
+
 async function isVectorizerInstalled(projectRoot: string): Promise<boolean> {
   try {
     await fs.access(path.join(projectRoot, ".opencode", "vectorizer", "node_modules"))
@@ -41,14 +108,14 @@ async function isVectorizerInstalled(projectRoot: string): Promise<boolean> {
   }
 }
 
-async function processPendingFiles(projectRoot: string): Promise<void> {
+async function processPendingFiles(projectRoot: string, config: VectorizerConfig): Promise<void> {
   if (pendingFiles.size === 0) return
   
   const now = Date.now()
   const filesToProcess: Map<string, string[]> = new Map()
   
   for (const [filePath, info] of pendingFiles.entries()) {
-    if (now - info.timestamp >= DEBOUNCE_MS) {
+    if (now - info.timestamp >= config.debounce_ms) {
       const files = filesToProcess.get(info.indexName) || []
       files.push(filePath)
       filesToProcess.set(info.indexName, files)
@@ -58,6 +125,8 @@ async function processPendingFiles(projectRoot: string): Promise<void> {
   
   if (filesToProcess.size === 0) return
   
+  debug(`Processing ${filesToProcess.size} index(es)...`)
+  
   try {
     const vectorizerModule = path.join(projectRoot, ".opencode", "vectorizer", "index.js")
     const { CodebaseIndexer } = await import(`file://${vectorizerModule}`)
@@ -69,40 +138,49 @@ async function processPendingFiles(projectRoot: string): Promise<void> {
         try {
           const wasIndexed = await indexer.indexSingleFile(filePath)
           if (wasIndexed) {
-            console.log(`[file-indexer] ✅ Reindexed: ${path.relative(projectRoot, filePath)} -> ${indexName}`)
+            console.log(`[file-indexer] Reindexed: ${path.relative(projectRoot, filePath)} -> ${indexName}`)
+          } else {
+            debug(`Skipped (unchanged): ${path.relative(projectRoot, filePath)}`)
           }
         } catch (e) {
-          // Silently ignore indexing errors
+          debug(`Error: ${(e as Error).message}`)
         }
       }
       
       await indexer.unloadModel()
     }
   } catch (e) {
-    // Silently ignore - vectorizer might not be installed
+    debug(`Fatal: ${(e as Error).message}`)
   }
 }
 
 export const FileIndexerPlugin: Plugin = async ({ directory }) => {
   let processingTimeout: NodeJS.Timeout | null = null
+  let config = await loadConfig(directory)
+  
+  // Check if plugin should be active
+  if (!config.enabled || !config.auto_index) {
+    debug(`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`)
   
   function queueFileForIndexing(filePath: string): void {
     const relativePath = path.relative(directory, filePath)
     
-    if (
-      relativePath.startsWith('node_modules') ||
-      relativePath.startsWith('.git') ||
-      relativePath.startsWith('.opencode/vectors') ||
-      relativePath.startsWith('.opencode/vectorizer') ||
-      relativePath.startsWith('dist') ||
-      relativePath.startsWith('build')
-    ) {
+    // Check exclusions from config
+    if (isExcluded(relativePath, config)) {
       return
     }
     
-    const indexName = getIndexForFile(filePath)
+    const indexName = getIndexForFile(filePath, config)
     if (!indexName) return
     
+    debug(`Queued: ${relativePath} -> ${indexName}`)
     pendingFiles.set(filePath, { indexName, timestamp: Date.now() })
     
     if (processingTimeout) {
@@ -110,32 +188,33 @@ export const FileIndexerPlugin: Plugin = async ({ directory }) => {
     }
     processingTimeout = setTimeout(async () => {
       if (await isVectorizerInstalled(directory)) {
-        await processPendingFiles(directory)
+        await processPendingFiles(directory, config)
+      } else {
+        debug(`Vectorizer not installed`)
       }
-    }, DEBOUNCE_MS + 100)
+    }, config.debounce_ms + 100)
   }
 
   return {
-    event: async ({ event }) => {
-      // file.edited - when agent edits a file
+    event: async (ctx) => {
+      const event = ctx.event
+      
       if (event.type === "file.edited") {
-        const filePath = event.data?.path || event.data?.filePath || event.data?.file
-        if (filePath) queueFileForIndexing(filePath)
+        const props = (event as any).properties || {}
+        const filePath = props.file || props.path || props.filePath
+        if (filePath) {
+          debug(`file.edited: ${filePath}`)
+          queueFileForIndexing(filePath)
+        }
       }
       
-      // file.watcher.updated - when file changes on disk
       if (event.type === "file.watcher.updated") {
-        const filePath = event.data?.path || event.data?.filePath || event.data?.file
-        if (filePath) queueFileForIndexing(filePath)
-      }
-    },
-    
-    "tool.execute.after": async (input, output) => {
-      const toolName = input.tool?.toLowerCase()
-      const filePath = input.args?.filePath
-      
-      if ((toolName === "edit" || toolName === "write" || toolName === "patch") && filePath) {
-        queueFileForIndexing(filePath)
+        const props = (event as any).properties || {}
+        const filePath = props.file || props.path || props.filePath
+        if (filePath) {
+          debug(`file.watcher.updated: ${filePath}`)
+          queueFileForIndexing(filePath)
+        }
       }
     },
   }