@comfanion/workflow 4.9.1 → 4.11.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.1",
+  "version": "4.11.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:48:49.653Z",
+  "buildDate": "2026-01-24T10:06:05.371Z",
   "files": [
     "config.yaml",
     "FLOW.yaml",

package/src/opencode/tools/codesearch.ts

@@ -43,6 +43,7 @@ Prerequisites: Run 'npx @comfanion/workflow index --index <name>' first.`,
     index: tool.schema.string().optional().default("code").describe("Index to search: code, docs, config, or custom name"),
     limit: tool.schema.number().optional().default(5).describe("Number of results to return (default: 5)"),
     searchAll: tool.schema.boolean().optional().default(false).describe("Search all indexes instead of just one"),
+    freshen: tool.schema.boolean().optional().default(true).describe("Auto-update stale files before searching (default: true)"),
   },
 
   async execute(args, context) {
@@ -65,6 +66,14 @@ Prerequisites: Run 'npx @comfanion/workflow index --index <name>' first.`,
       const limit = args.limit || 5
       const indexName = args.index || "code"
 
+      // Auto-freshen stale files before searching
+      let freshenStats = { updated: 0 }
+      if (args.freshen !== false) {
+        const tempIndexer = await new CodebaseIndexer(projectRoot, args.index || "code").init()
+        freshenStats = await tempIndexer.freshen()
+        await tempIndexer.unloadModel() // Free memory after freshen
+      }
+
       if (args.searchAll) {
         // Search all indexes
         const tempIndexer = await new CodebaseIndexer(projectRoot, "code").init()
@@ -76,8 +85,12 @@ Prerequisites: Run 'npx @comfanion/workflow index --index <name>' first.`,
 
         for (const idx of indexes) {
           const indexer = await new CodebaseIndexer(projectRoot, idx).init()
+          if (args.freshen !== false) {
+            await indexer.freshen()
+          }
           const results = await indexer.search(args.query, limit)
           allResults.push(...results.map((r: any) => ({ ...r, _index: idx })))
+          await indexer.unloadModel() // Free memory after each index search
         }
 
         // Sort by distance and take top N
@@ -96,6 +109,7 @@ Prerequisites: Run 'npx @comfanion/workflow index --index <name>' first.`,
         const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
         const results = await indexer.search(args.query, limit)
         allResults = results.map((r: any) => ({ ...r, _index: indexName }))
+        await indexer.unloadModel() // Free memory after search
       }
 
       if (allResults.length === 0) {

package/src/vectorizer/index.js

@@ -196,6 +196,54 @@ class CodebaseIndexer {
     return results;
   }
 
+  /**
+   * Freshen index - check for stale files and reindex only changed ones
+   * Returns { checked, updated, deleted } counts
+   */
+  async freshen() {
+    let checked = 0;
+    let updated = 0;
+    let deleted = 0;
+
+    const indexedFiles = Object.keys(this.hashes);
+    
+    for (const relPath of indexedFiles) {
+      checked++;
+      const filePath = path.join(this.root, relPath);
+      
+      try {
+        const content = await fs.readFile(filePath, 'utf8');
+        const currentHash = this.fileHash(content);
+        
+        if (this.hashes[relPath] !== currentHash) {
+          // File changed - reindex it
+          await this.indexFile(filePath);
+          updated++;
+        }
+      } catch (e) {
+        // File deleted or unreadable - remove from index
+        delete this.hashes[relPath];
+        deleted++;
+      }
+    }
+    
+    if (deleted > 0) {
+      await this.saveHashes();
+    }
+    
+    return { checked, updated, deleted };
+  }
+
+  /**
+   * Index a single file by path (convenience method)
+   */
+  async indexSingleFile(filePath) {
+    const absPath = path.isAbsolute(filePath) 
+      ? filePath 
+      : path.join(this.root, filePath);
+    return await this.indexFile(absPath);
+  }
+
   /**
    * Get indexing statistics for this index
    */