@comfanion/workflow 4.9.0 → 4.10.0

package/bin/cli.js

@@ -235,13 +235,41 @@ program
     const spinner = ora('Initializing OpenCode Workflow...').start();
 
     try {
-      // If updating, create backup and remove old directory
+      // If updating, preserve vectorizer and indexes
+      const vectorizerDir = path.join(targetDir, 'vectorizer');
+      const vectorsDir = path.join(targetDir, 'vectors');
+      const vectorizerNodeModules = path.join(vectorizerDir, 'node_modules');
+      const tempNodeModules = path.join(process.cwd(), '.vectorizer-node_modules-temp');
+      const tempVectors = path.join(process.cwd(), '.vectors-temp');
+      
+      let hadVectorizer = false;
+      let hadVectors = false;
+      
       if (await fs.pathExists(targetDir)) {
         const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
         const backupDir = path.join(process.cwd(), `.opencode.backup-${timestamp}`);
         
+        // Check what we need to preserve
+        hadVectorizer = await fs.pathExists(vectorizerNodeModules);
+        hadVectors = await fs.pathExists(vectorsDir);
+        
+        // Preserve vectorizer node_modules (100MB+, don't backup)
+        if (hadVectorizer) {
+          spinner.text = 'Preserving vectorizer dependencies...';
+          await fs.move(vectorizerNodeModules, tempNodeModules, { overwrite: true });
+        }
+        
+        // Preserve vector indexes
+        if (hadVectors) {
+          spinner.text = 'Preserving vector indexes...';
+          await fs.move(vectorsDir, tempVectors, { overwrite: true });
+        }
+        
+        // Create backup (without node_modules and vectors)
         spinner.text = 'Creating backup...';
-        await fs.copy(targetDir, backupDir);
+        await fs.copy(targetDir, backupDir, {
+          filter: (src) => !src.includes('node_modules') && !src.includes('vectors')
+        });
         
         spinner.text = 'Removing old .opencode/...';
         await fs.remove(targetDir);
@@ -254,6 +282,27 @@ program
       // Copy .opencode structure (fresh, no old files)
       await fs.copy(OPENCODE_SRC, targetDir);
       
+      // Copy updated vectorizer source files
+      if (await fs.pathExists(VECTORIZER_SRC)) {
+        spinner.text = 'Updating vectorizer...';
+        const newVectorizerDir = path.join(targetDir, 'vectorizer');
+        await fs.ensureDir(newVectorizerDir);
+        await fs.copy(path.join(VECTORIZER_SRC, 'index.js'), path.join(newVectorizerDir, 'index.js'));
+        await fs.copy(path.join(VECTORIZER_SRC, 'package.json'), path.join(newVectorizerDir, 'package.json'));
+      }
+      
+      // Restore vectorizer node_modules
+      if (hadVectorizer) {
+        spinner.text = 'Restoring vectorizer dependencies...';
+        await fs.move(tempNodeModules, path.join(targetDir, 'vectorizer', 'node_modules'), { overwrite: true });
+      }
+      
+      // Restore vector indexes
+      if (hadVectors) {
+        spinner.text = 'Restoring vector indexes...';
+        await fs.move(tempVectors, path.join(targetDir, 'vectors'), { overwrite: true });
+      }
+      
       // Update config.yaml with user values
       spinner.text = 'Configuring...';
       const configPath = path.join(targetDir, 'config.yaml');
@@ -332,8 +381,16 @@ program
 
       spinner.succeed(chalk.green('OpenCode Workflow initialized!'));
 
-      // Install vectorizer if requested
-      if (config.install_vectorizer) {
+      // Show what was preserved
+      if (hadVectorizer) {
+        console.log(chalk.green('✅ Vectorizer updated (dependencies preserved)'));
+      }
+      if (hadVectors) {
+        console.log(chalk.green('✅ Vector indexes preserved'));
+      }
+
+      // Install vectorizer if requested (and not already installed)
+      if (config.install_vectorizer && !hadVectorizer) {
         await installVectorizer(targetDir);
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.9.0",
+  "version": "4.10.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-24T09:33:58.989Z",
+  "buildDate": "2026-01-24T09:51:33.276Z",
   "files": [
     "config.yaml",
     "FLOW.yaml",

package/src/opencode/agents/crawler.md

@@ -119,8 +119,14 @@ permission:
   </prefer-lsp-when>
 </lsp-exploration>
 
-<codesearch-exploration hint="Semantic search with MULTI-INDEX support">
-  <check>codeindex({ action: "list" }) → See all indexes. If none, suggest: npx opencode-workflow index --index code</check>
+<codesearch-exploration hint="ALWAYS TRY SEMANTIC SEARCH FIRST">
+  <critical>
+    BEFORE using grep/glob, ALWAYS check: codeindex({ action: "list" })
+    If indexes exist → USE codesearch instead of grep!
+    codesearch returns 5-10 relevant files vs 100+ grep matches
+  </critical>
+  
+  <first-step>codeindex({ action: "list" }) → Check if indexes exist</first-step>
   
   <indexes hint="Different indexes for different content types">
     <index name="code">Source code (*.go, *.ts, *.py) - functions, classes, logic</index>
@@ -175,14 +181,22 @@ permission:
     - Regex pattern matching needed
   </use-grep-when>
   
-  <exploration-strategy>
-    1. codeindex({ action: "list" }) → Check what indexes exist
-    2. codesearch({ query: "high-level concept", index: "code" }) → Find relevant code areas
-    3. codesearch({ query: "explanation", index: "docs" }) → Find related documentation
-    4. Read top results to understand structure
-    5. lsp documentSymbol on key files → Get detailed structure
-    6. grep for specific patterns if needed
+  <exploration-strategy priority="MANDATORY">
+    1. FIRST: codeindex({ action: "list" }) → Check what indexes exist
+    2. IF indexes exist:
+       - codesearch({ query: "concept", index: "code" }) → 5-10 relevant files (NOT 100+ grep matches!)
+       - Read top 3-5 results
+       - Done! Much faster than grep
+    3. IF no indexes:
+       - Suggest: "Index not found. Create with: codeindex({ action: 'reindex', index: 'code' })"
+       - Fall back to grep/glob
+    4. Use grep ONLY for exact string matches (function names, imports)
   </exploration-strategy>
+  
+  <efficiency-comparison>
+    BAD:  grep "category.*mapping" → 100 matches → read 20 files → slow!
+    GOOD: codesearch({ query: "category mapping logic" }) → 5 files → fast!
+  </efficiency-comparison>
 </codesearch-exploration>
 
 </agent>