@comfanion/workflow 4.6.0 → 4.7.0

package/bin/cli.js

@@ -402,8 +402,9 @@ program
 
 program
   .command('update')
-  .description('Update .opencode/ to latest version (preserves config.yaml)')
+  .description('Update .opencode/ to latest version (preserves config.yaml and vectorizer)')
   .option('--no-backup', 'Skip creating backup')
+  .option('--vectorizer', 'Update/install vectorizer too')
   .action(async (options) => {
     const spinner = ora('Updating OpenCode Workflow...').start();
     
@@ -416,6 +417,8 @@ program
       }
       
       const configPath = path.join(targetDir, 'config.yaml');
+      const vectorizerDir = path.join(targetDir, 'vectorizer');
+      const vectorsDir = path.join(targetDir, 'vectors');
       const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
       const backupDir = path.join(process.cwd(), `.opencode.backup-${timestamp}`);
       
@@ -423,13 +426,32 @@ program
       spinner.text = 'Reading config.yaml...';
       const configBackup = await fs.readFile(configPath, 'utf8');
       
+      // Check if vectorizer exists
+      const hasVectorizer = await fs.pathExists(path.join(vectorizerDir, 'node_modules'));
+      const hasVectors = await fs.pathExists(vectorsDir);
+      
       // Create full backup (unless --no-backup)
       if (options.backup !== false) {
         spinner.text = 'Creating backup...';
-        await fs.copy(targetDir, backupDir);
+        await fs.copy(targetDir, backupDir, {
+          filter: (src) => !src.includes('node_modules') && !src.includes('vectors')
+        });
       }
       
-      // Remove old .opencode directory completely
+      // Preserve vectorizer and vectors by moving them temporarily
+      const tempVectorizer = path.join(process.cwd(), '.vectorizer-temp');
+      const tempVectors = path.join(process.cwd(), '.vectors-temp');
+      
+      if (hasVectorizer) {
+        spinner.text = 'Preserving vectorizer...';
+        await fs.move(vectorizerDir, tempVectorizer, { overwrite: true });
+      }
+      if (hasVectors) {
+        spinner.text = 'Preserving vector indexes...';
+        await fs.move(vectorsDir, tempVectors, { overwrite: true });
+      }
+      
+      // Remove old .opencode directory
       spinner.text = 'Removing old files...';
       await fs.remove(targetDir);
       
@@ -437,6 +459,16 @@ program
       spinner.text = 'Installing new version...';
       await fs.copy(OPENCODE_SRC, targetDir);
       
+      // Restore vectorizer and vectors
+      if (hasVectorizer) {
+        spinner.text = 'Restoring vectorizer...';
+        await fs.move(tempVectorizer, vectorizerDir, { overwrite: true });
+      }
+      if (hasVectors) {
+        spinner.text = 'Restoring vector indexes...';
+        await fs.move(tempVectors, vectorsDir, { overwrite: true });
+      }
+      
       // Restore user's config.yaml
       spinner.text = 'Restoring config.yaml...';
       await fs.writeFile(configPath, configBackup);
@@ -448,7 +480,24 @@ program
         console.log(chalk.gray('   You can delete it after verifying the update works.\n'));
       }
       
-      console.log(chalk.green('✅ Your config.yaml was preserved.\n'));
+      console.log(chalk.green('✅ Your config.yaml was preserved.'));
+      if (hasVectorizer) {
+        console.log(chalk.green('✅ Vectorizer was preserved.'));
+      }
+      if (hasVectors) {
+        console.log(chalk.green('✅ Vector indexes were preserved.'));
+      }
+      
+      // Option to install/update vectorizer
+      if (options.vectorizer) {
+        console.log('');
+        await installVectorizer(targetDir);
+      } else if (!hasVectorizer) {
+        console.log(chalk.yellow('\n💡 Vectorizer not installed. Install with:'));
+        console.log(chalk.cyan('   npx opencode-workflow vectorizer install\n'));
+      }
+      
+      console.log('');
       
     } catch (error) {
       spinner.fail(chalk.red('Failed to update'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.6.0",
+  "version": "4.7.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:20:56.596Z",
+  "buildDate": "2026-01-24T09:24:45.283Z",
   "files": [
     "config.yaml",
     "FLOW.yaml",

package/src/opencode/tools/codeindex.ts

@@ -14,27 +14,13 @@
 import { tool } from "@opencode-ai/plugin"
 import path from "path"
 import fs from "fs/promises"
-import { glob } from "glob"
-import ignore from "ignore"
+import { execSync } from "child_process"
 
-// Index presets (duplicated from vectorizer for independence)
+// Index presets for documentation
 const INDEX_PRESETS: Record<string, { pattern: string; description: string }> = {
-  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'
-  },
-  docs: {
-    pattern: '**/*.{md,mdx,txt,rst,adoc}',
-    description: 'Documentation files'
-  },
-  config: {
-    pattern: '**/*.{yaml,yml,json,toml,ini,env,xml}',
-    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}',
-    description: 'All supported files'
-  }
+  code: { pattern: '**/*.{js,ts,go,py,...}', description: 'Source code files' },
+  docs: { pattern: '**/*.{md,txt,...}', description: 'Documentation files' },
+  config: { pattern: '**/*.{yaml,json,...}', description: 'Configuration files' },
 }
 
 export default tool({
@@ -54,7 +40,7 @@ Note: Initial indexing takes ~30s to load the embedding model.`,
 
   args: {
     action: tool.schema.enum(["status", "list", "reindex"]).describe("Action to perform"),
-    index: tool.schema.string().optional().default("code").describe("Index name for status/reindex: code, docs, config"),
+    index: tool.schema.string().optional().default("code").describe("Index name: code, docs, config"),
   },
 
   async execute(args, context) {
@@ -72,83 +58,93 @@ Note: Initial indexing takes ~30s to load the embedding model.`,
 
 To install:
 \`\`\`bash
-npx opencode-workflow vectorizer install
+npx @comfanion/workflow vectorizer install
 \`\`\`
 
 This will download the embedding model (~100MB) and set up the vector database.`
     }
 
-    try {
-      const vectorizerModule = path.join(vectorizerDir, "index.js")
-      const { CodebaseIndexer, INDEX_PRESETS: PRESETS } = await import(`file://${vectorizerModule}`)
-
-      // LIST: Show all indexes
-      if (args.action === "list") {
-        const tempIndexer = await new CodebaseIndexer(projectRoot, "code").init()
-        const allStats = await tempIndexer.getAllStats()
+    const indexName = args.index || "code"
 
+    // LIST: Show all indexes
+    if (args.action === "list") {
+      try {
+        const result = execSync("node .opencode/vectorizer/list-indexes.js 2>/dev/null || echo '{}'", {
+          cwd: projectRoot,
+          encoding: "utf8",
+          timeout: 30000
+        })
+        
+        // Fallback: read hashes files directly
         let output = `## Codebase Index Overview\n\n`
         output += `✅ **Vectorizer installed**\n\n`
-
-        if (allStats.length === 0) {
+        
+        const indexes: string[] = []
+        try {
+          const entries = await fs.readdir(vectorsDir, { withFileTypes: true })
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              indexes.push(entry.name)
+            }
+          }
+        } catch {}
+        
+        if (indexes.length === 0) {
           output += `⚠️ **No indexes created yet**\n\n`
           output += `Create indexes with:\n`
           output += `\`\`\`bash\n`
-          output += `npx opencode-workflow index --index code   # Source code\n`
-          output += `npx opencode-workflow index --index docs   # Documentation\n`
-          output += `npx opencode-workflow index --index config # Config files\n`
-          output += `\`\`\`\n\n`
+          output += `npx opencode-workflow index --index code\n`
+          output += `npx opencode-workflow index --index docs --dir docs/\n`
+          output += `\`\`\`\n`
         } else {
           output += `### Active Indexes\n\n`
-          for (const stat of allStats) {
-            output += `**📁 ${stat.indexName}** - ${stat.description}\n`
-            output += `   Files: ${stat.fileCount}, Chunks: ${stat.chunkCount}\n\n`
+          for (const idx of indexes) {
+            try {
+              const hashesPath = path.join(vectorsDir, idx, "hashes.json")
+              const hashes = JSON.parse(await fs.readFile(hashesPath, "utf8"))
+              const fileCount = Object.keys(hashes).length
+              const desc = INDEX_PRESETS[idx]?.description || "Custom index"
+              output += `**📁 ${idx}** - ${desc}\n`
+              output += `   Files: ${fileCount}\n\n`
+            } catch {}
           }
         }
-
-        output += `### Available Presets\n\n`
-        for (const [name, preset] of Object.entries(PRESETS || INDEX_PRESETS) as [string, any][]) {
-          const exists = allStats.find((s: any) => s.indexName === name)
-          const status = exists ? "✅" : "⬜"
-          output += `${status} **${name}**: ${preset.description}\n`
-        }
-
-        output += `\n### Usage\n`
+        
+        output += `### Usage\n`
         output += `\`\`\`\n`
         output += `codesearch({ query: "your query", index: "code" })\n`
-        output += `codesearch({ query: "deployment guide", index: "docs" })\n`
-        output += `codesearch({ query: "api keys", searchAll: true })\n`
+        output += `codesearch({ query: "how to deploy", index: "docs" })\n`
         output += `\`\`\``
-
+        
         return output
+        
+      } catch (error: any) {
+        return `❌ Error listing indexes: ${error.message}`
       }
+    }
 
-      // STATUS: Show specific index status
-      if (args.action === "status") {
-        const indexName = args.index || "code"
-        const hashesFile = path.join(vectorsDir, indexName, "hashes.json")
-
-        try {
-          const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
-          const stats = await indexer.getStats()
-
-          // Get sample files
-          const hashesContent = await fs.readFile(hashesFile, "utf8")
-          const hashes = JSON.parse(hashesContent)
-          const sampleFiles = Object.keys(hashes).slice(0, 5)
+    // STATUS: Show specific index status
+    if (args.action === "status") {
+      const hashesFile = path.join(vectorsDir, indexName, "hashes.json")
+      
+      try {
+        const hashesContent = await fs.readFile(hashesFile, "utf8")
+        const hashes = JSON.parse(hashesContent)
+        const fileCount = Object.keys(hashes).length
+        const sampleFiles = Object.keys(hashes).slice(0, 5)
+        const desc = INDEX_PRESETS[indexName]?.description || "Custom index"
 
-          return `## Index Status: "${indexName}"
+        return `## Index Status: "${indexName}"
 
 ✅ **Vectorizer installed**
 ✅ **Index active**
 
-**Description:** ${stats.description}
-**Files indexed:** ${stats.fileCount}
-**Chunks:** ${stats.chunkCount}
+**Description:** ${desc}
+**Files indexed:** ${fileCount}
 
 **Sample indexed files:**
 ${sampleFiles.map(f => `- ${f}`).join("\n")}
-${stats.fileCount > 5 ? `- ... and ${stats.fileCount - 5} more` : ""}
+${fileCount > 5 ? `- ... and ${fileCount - 5} more` : ""}
 
 **Usage:**
 \`\`\`
@@ -156,12 +152,12 @@ codesearch({ query: "your search query", index: "${indexName}" })
 \`\`\`
 
 To re-index:
-\`\`\`
-codeindex({ action: "reindex", index: "${indexName}" })
+\`\`\`bash
+npx opencode-workflow index --index ${indexName}
 \`\`\``
 
-        } catch {
-          return `## Index Status: "${indexName}"
+      } catch {
+        return `## Index Status: "${indexName}"
 
 ✅ **Vectorizer installed**
 ⚠️ **Index "${indexName}" not created yet**
@@ -169,87 +165,47 @@ codeindex({ action: "reindex", index: "${indexName}" })
 To create this index:
 \`\`\`bash
 npx opencode-workflow index --index ${indexName}
-\`\`\`
-
-Or use:
-\`\`\`
-codeindex({ action: "reindex", index: "${indexName}" })
+# Or with specific directory:
+npx opencode-workflow index --index ${indexName} --dir src/
 \`\`\``
-        }
       }
+    }
 
-      // REINDEX: Re-index specific index (do it directly, no shell)
-      if (args.action === "reindex") {
-        const indexName = args.index || "code"
-        
-        try {
-          const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
-          
-          // Get pattern from preset
-          const preset = (PRESETS || INDEX_PRESETS)[indexName]
-          const pattern = preset?.pattern || '**/*.{js,ts,py,go,md,yaml,json}'
-          
-          // Load .gitignore
-          let ig = ignore()
-          try {
-            const gitignore = await fs.readFile(path.join(projectRoot, '.gitignore'), 'utf8')
-            ig = ig.add(gitignore)
-          } catch {}
-          ig.add(['node_modules', '.git', 'dist', 'build', '.opencode/vectors', '.opencode/vectorizer'])
-          
-          // Find files
-          const files = await glob(pattern, { cwd: projectRoot, nodir: true })
-          const filtered = files.filter((f: string) => !ig.ignores(f))
-          
-          let indexed = 0
-          let skipped = 0
-          
-          for (const file of filtered) {
-            const filePath = path.join(projectRoot, file)
-            try {
-              const wasIndexed = await indexer.indexFile(filePath)
-              if (wasIndexed) {
-                indexed++
-              } else {
-                skipped++
-              }
-            } catch {
-              // Skip files that can't be read
-            }
-          }
-          
-          // Unload model to free memory
-          await indexer.unloadModel()
-          
-          const stats = await indexer.getStats()
+    // REINDEX: Re-index using CLI
+    if (args.action === "reindex") {
+      try {
+        execSync(`npx opencode-workflow index --index ${indexName}`, {
+          cwd: projectRoot,
+          encoding: "utf8",
+          timeout: 300000, // 5 min
+          stdio: "pipe"
+        })
+
+        // Get stats after indexing
+        const hashesFile = path.join(vectorsDir, indexName, "hashes.json")
+        const hashes = JSON.parse(await fs.readFile(hashesFile, "utf8"))
+        const fileCount = Object.keys(hashes).length
 
-          return `## Re-indexing Complete ✅
+        return `## Re-indexing Complete ✅
 
 **Index:** ${indexName}
-**Description:** ${stats.description}
-**Files found:** ${filtered.length}
-**Files indexed:** ${indexed}
-**Files unchanged:** ${skipped}
-**Total chunks:** ${stats.chunkCount}
+**Files indexed:** ${fileCount}
 
 You can now use semantic search:
 \`\`\`
 codesearch({ query: "your search query", index: "${indexName}" })
 \`\`\``
 
-        } catch (error: any) {
-          return `❌ Re-indexing failed: ${error.message}
+      } catch (error: any) {
+        return `❌ Re-indexing failed: ${error.message}
 
-Try:
-1. Check if vectorizer is installed: \`npx opencode-workflow vectorizer status\`
-2. Re-install vectorizer: \`npx opencode-workflow vectorizer install\``
-        }
+Try manually:
+\`\`\`bash
+npx opencode-workflow index --index ${indexName} --force
+\`\`\``
       }
-
-      return `Unknown action: ${args.action}. Use: status, list, or reindex`
-
-    } catch (error: any) {
-      return `❌ Error: ${error.message}`
     }
+
+    return `Unknown action: ${args.action}. Use: status, list, or reindex`
   },
 })