@comfanion/workflow 4.7.1 → 4.9.0

package/bin/cli.js

@@ -438,13 +438,14 @@ program
         });
       }
       
-      // Preserve vectorizer and vectors by moving them temporarily
-      const tempVectorizer = path.join(process.cwd(), '.vectorizer-temp');
+      // Preserve vectorizer node_modules and vectors by moving them temporarily
+      const tempNodeModules = path.join(process.cwd(), '.vectorizer-node_modules-temp');
       const tempVectors = path.join(process.cwd(), '.vectors-temp');
+      const vectorizerNodeModules = path.join(vectorizerDir, 'node_modules');
       
       if (hasVectorizer) {
-        spinner.text = 'Preserving vectorizer...';
-        await fs.move(vectorizerDir, tempVectorizer, { overwrite: true });
+        spinner.text = 'Preserving vectorizer dependencies...';
+        await fs.move(vectorizerNodeModules, tempNodeModules, { overwrite: true });
       }
       if (hasVectors) {
         spinner.text = 'Preserving vector indexes...';
@@ -455,18 +456,27 @@ program
       spinner.text = 'Removing old files...';
       await fs.remove(targetDir);
       
-      // Copy new files
+      // Copy new files (including updated vectorizer source)
       spinner.text = 'Installing new version...';
       await fs.copy(OPENCODE_SRC, targetDir);
       
-      // Restore vectorizer and vectors
+      // Copy new 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 and vectors
       if (hasVectorizer) {
-        spinner.text = 'Restoring vectorizer...';
-        await fs.move(tempVectorizer, vectorizerDir, { overwrite: true });
+        spinner.text = 'Restoring vectorizer dependencies...';
+        await fs.move(tempNodeModules, path.join(targetDir, 'vectorizer', 'node_modules'), { overwrite: true });
       }
       if (hasVectors) {
         spinner.text = 'Restoring vector indexes...';
-        await fs.move(tempVectors, vectorsDir, { overwrite: true });
+        await fs.move(tempVectors, path.join(targetDir, 'vectors'), { overwrite: true });
       }
       
       // Restore user's config.yaml
@@ -482,7 +492,7 @@ program
       
       console.log(chalk.green('✅ Your config.yaml was preserved.'));
       if (hasVectorizer) {
-        console.log(chalk.green('✅ Vectorizer was preserved.'));
+        console.log(chalk.green('✅ Vectorizer updated (node_modules preserved).'));
       }
       if (hasVectors) {
         console.log(chalk.green('✅ Vector indexes were preserved.'));

package/package.json

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

package/src/opencode/tools/codeindex.ts

@@ -2,7 +2,7 @@
  * Code Index Status & Management Tool
  * 
  * Check indexing status and trigger re-indexing.
- * Supports multiple indexes: code, docs, config.
+ * Uses LOCAL vectorizer - no npm calls needed.
  * 
  * Usage by model:
  *   codeindex({ action: "status" })
@@ -14,38 +14,78 @@
 import { tool } from "@opencode-ai/plugin"
 import path from "path"
 import fs from "fs/promises"
-import { execSync } from "child_process"
 
-// Index presets for documentation
-const INDEX_PRESETS: Record<string, { pattern: string; description: string }> = {
-  code: { pattern: '**/*.{js,ts,go,py,...}', description: 'Source code files' },
-  docs: { pattern: '**/*.{md,txt,...}', description: 'Documentation files' },
-  config: { pattern: '**/*.{yaml,json,...}', description: 'Configuration files' },
+// File extensions for each index type
+const INDEX_EXTENSIONS: Record<string, string[]> = {
+  code: ['.js', '.ts', '.jsx', '.tsx', '.go', '.py', '.rs', '.java', '.kt', '.swift', '.c', '.cpp', '.h', '.cs', '.rb', '.php'],
+  docs: ['.md', '.mdx', '.txt', '.rst', '.adoc'],
+  config: ['.yaml', '.yml', '.json', '.toml', '.ini', '.xml'],
+}
+
+const INDEX_DESCRIPTIONS: Record<string, string> = {
+  code: 'Source code files',
+  docs: 'Documentation files',
+  config: 'Configuration files',
+}
+
+// Simple recursive file walker (no external deps)
+async function walkDir(dir: string, extensions: string[], ignore: string[] = []): Promise<string[]> {
+  const files: string[] = []
+  
+  async function walk(currentDir: string) {
+    try {
+      const entries = await fs.readdir(currentDir, { withFileTypes: true })
+      
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name)
+        const relativePath = path.relative(dir, fullPath)
+        
+        // Skip ignored directories
+        if (ignore.some(ig => relativePath.startsWith(ig) || entry.name === ig)) {
+          continue
+        }
+        
+        if (entry.isDirectory()) {
+          await walk(fullPath)
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase()
+          if (extensions.includes(ext)) {
+            files.push(fullPath)
+          }
+        }
+      }
+    } catch {}
+  }
+  
+  await walk(dir)
+  return files
 }
 
 export default tool({
   description: `Check codebase index status or trigger re-indexing for semantic search.
 
 Actions:
-- "status" → Show index statistics (specify index or see all)
+- "status" → Show index statistics
 - "list" → List all available indexes with stats
-- "reindex" → Re-index files (specify which index)
+- "reindex" → Re-index files using LOCAL vectorizer (no npm needed)
 
 Available indexes:
-- "code" - Source code files
-- "docs" - Documentation files  
-- "config" - Configuration files
+- "code" - Source code files (.js, .ts, .go, .py, etc.)
+- "docs" - Documentation files (.md, .txt, etc.)
+- "config" - Configuration files (.yaml, .json, etc.)
 
-Note: Initial indexing takes ~30s to load the embedding model.`,
+Note: First indexing takes ~30s to load embedding model.`,
 
   args: {
     action: tool.schema.enum(["status", "list", "reindex"]).describe("Action to perform"),
     index: tool.schema.string().optional().default("code").describe("Index name: code, docs, config"),
+    dir: tool.schema.string().optional().describe("Directory to index (default: project root)"),
   },
 
   async execute(args, context) {
     const projectRoot = process.cwd()
     const vectorizerDir = path.join(projectRoot, ".opencode", "vectorizer")
+    const vectorizerModule = path.join(vectorizerDir, "index.js")
     const vectorsDir = path.join(projectRoot, ".opencode", "vectors")
 
     // Check if vectorizer is installed
@@ -56,71 +96,59 @@ Note: Initial indexing takes ~30s to load the embedding model.`,
     if (!isInstalled) {
       return `❌ Vectorizer not installed.
 
-To install:
+To install, run in terminal:
 \`\`\`bash
 npx @comfanion/workflow vectorizer install
 \`\`\`
 
-This will download the embedding model (~100MB) and set up the vector database.`
+This downloads the embedding model (~100MB).`
     }
 
     const indexName = args.index || "code"
 
     // LIST: Show all indexes
     if (args.action === "list") {
+      let output = `## Codebase Index Overview\n\n`
+      output += `✅ **Vectorizer installed**\n\n`
+      
+      const indexes: string[] = []
       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`
-        
-        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 @comfanion/workflow index --index code\n`
-          output += `npx @comfanion/workflow index --index docs --dir docs/\n`
-          output += `\`\`\`\n`
-        } else {
-          output += `### Active Indexes\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 {}
+        const entries = await fs.readdir(vectorsDir, { withFileTypes: true })
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            indexes.push(entry.name)
           }
         }
-        
-        output += `### Usage\n`
+      } catch {}
+      
+      if (indexes.length === 0) {
+        output += `⚠️ **No indexes created yet**\n\n`
+        output += `Create indexes:\n`
         output += `\`\`\`\n`
-        output += `codesearch({ query: "your query", index: "code" })\n`
-        output += `codesearch({ query: "how to deploy", index: "docs" })\n`
-        output += `\`\`\``
-        
-        return output
-        
-      } catch (error: any) {
-        return `❌ Error listing indexes: ${error.message}`
+        output += `codeindex({ action: "reindex", index: "code" })\n`
+        output += `codeindex({ action: "reindex", index: "docs", dir: "docs/" })\n`
+        output += `\`\`\`\n`
+      } else {
+        output += `### Active Indexes\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_DESCRIPTIONS[idx] || "Custom index"
+            output += `**📁 ${idx}** - ${desc}\n`
+            output += `   Files: ${fileCount}\n\n`
+          } catch {}
+        }
       }
+      
+      output += `### Usage\n`
+      output += `\`\`\`\n`
+      output += `codesearch({ query: "your query", index: "code" })\n`
+      output += `codesearch({ query: "how to deploy", index: "docs" })\n`
+      output += `\`\`\``
+      
+      return output
     }
 
     // STATUS: Show specific index status
@@ -132,7 +160,7 @@ This will download the embedding model (~100MB) and set up the vector database.`
         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"
+        const desc = INDEX_DESCRIPTIONS[indexName] || "Custom index"
 
         return `## Index Status: "${indexName}"
 
@@ -152,8 +180,8 @@ codesearch({ query: "your search query", index: "${indexName}" })
 \`\`\`
 
 To re-index:
-\`\`\`bash
-npx @comfanion/workflow index --index ${indexName}
+\`\`\`
+codeindex({ action: "reindex", index: "${indexName}" })
 \`\`\``
 
       } catch {
@@ -163,33 +191,58 @@ npx @comfanion/workflow index --index ${indexName}
 ⚠️ **Index "${indexName}" not created yet**
 
 To create this index:
-\`\`\`bash
-npx @comfanion/workflow index --index ${indexName}
-# Or with specific directory:
-npx @comfanion/workflow index --index ${indexName} --dir src/
+\`\`\`
+codeindex({ action: "reindex", index: "${indexName}" })
+\`\`\`
+
+Or with specific directory:
+\`\`\`
+codeindex({ action: "reindex", index: "${indexName}", dir: "src/" })
 \`\`\``
       }
     }
 
-    // REINDEX: Re-index using CLI
+    // REINDEX: Re-index using LOCAL vectorizer (no npm!)
     if (args.action === "reindex") {
       try {
-        execSync(`npx @comfanion/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
+        // Import local vectorizer
+        const { CodebaseIndexer } = await import(`file://${vectorizerModule}`)
+        const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
+        
+        // Determine directory and extensions
+        const baseDir = args.dir 
+          ? path.resolve(projectRoot, args.dir)
+          : projectRoot
+        const extensions = INDEX_EXTENSIONS[indexName] || INDEX_EXTENSIONS.code
+        
+        // Find files using simple walker
+        const ignoreList = ['node_modules', '.git', 'dist', 'build', '.opencode', 'vendor', '__pycache__']
+        const files = await walkDir(baseDir, extensions, ignoreList)
+        
+        let indexed = 0
+        let skipped = 0
+        
+        for (const filePath of files) {
+          try {
+            const wasIndexed = await indexer.indexFile(filePath)
+            if (wasIndexed) indexed++
+            else skipped++
+          } catch {}
+        }
+        
+        // Unload model to free memory
+        await indexer.unloadModel()
+        
+        const stats = await indexer.getStats()
 
         return `## Re-indexing Complete ✅
 
 **Index:** ${indexName}
-**Files indexed:** ${fileCount}
+**Directory:** ${args.dir || "(project root)"}
+**Files found:** ${files.length}
+**Files indexed:** ${indexed}
+**Files unchanged:** ${skipped}
+**Total chunks:** ${stats.chunkCount}
 
 You can now use semantic search:
 \`\`\`
@@ -199,9 +252,9 @@ codesearch({ query: "your search query", index: "${indexName}" })
       } catch (error: any) {
         return `❌ Re-indexing failed: ${error.message}
 
-Try manually:
+Make sure vectorizer is installed:
 \`\`\`bash
-npx @comfanion/workflow index --index ${indexName} --force
+npx @comfanion/workflow vectorizer install
 \`\`\``
       }
     }