@comfanion/workflow 4.38.3-dev.2 → 4.38.4-dev.0

package/src/opencode/plugins/version-check.ts

@@ -1,230 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin"
-import path from "path"
-import fs from "fs/promises"
-import https from "https"
-
-/**
- * Version Check Plugin
- * 
- * Checks if a newer version of @comfanion/workflow is available on npm.
- * Shows a toast notification if an update is available.
- * 
- * Configuration in .opencode/config.yaml:
- *   version_check:
- *     enabled: true       # Enable version checking
- *     check_interval: 3600000  # Check once per hour (ms)
- */
-
-const DEBUG = process.env.DEBUG?.includes('version-check') || process.env.DEBUG === '*'
-const PACKAGE_NAME = '@comfanion/workflow'
-const CACHE_FILE = '.version-check-cache.json'
-
-function log(msg: string): void {
-  if (DEBUG) console.log(`[version-check] ${msg}`)
-}
-
-interface VersionCache {
-  lastCheck: number
-  latestVersion: string
-}
-
-async function getLocalVersion(directory: string): Promise<string | null> {
-  try {
-    // Try build-info.json first (created during npm publish)
-    const buildInfoPath = path.join(directory, '.opencode', 'build-info.json')
-    const buildInfo = JSON.parse(await fs.readFile(buildInfoPath, 'utf8'))
-    if (buildInfo.version) return buildInfo.version
-  } catch {}
-  
-  try {
-    // Fallback to config.yaml version field
-    const configPath = path.join(directory, '.opencode', 'config.yaml')
-    const config = await fs.readFile(configPath, 'utf8')
-    const match = config.match(/^version:\s*["']?([\d.]+)["']?/m)
-    if (match) return match[1]
-  } catch {}
-  
-  return null
-}
-
-async function getLatestVersion(): Promise<string | null> {
-  return new Promise((resolve) => {
-    let settled = false
-    const done = (value: string | null) => {
-      if (settled) return
-      settled = true
-      clearTimeout(timeout)
-      resolve(value)
-    }
-
-    const timeout = setTimeout(() => {
-      done(null)
-      req.destroy() // Destroy socket on timeout to prevent leak
-    }, 5000)
-
-    const req = https.get(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, (res) => {
-      let data = ''
-      res.on('data', chunk => {
-        if (!settled) data += chunk // Stop accumulating after settled
-      })
-      res.on('end', () => {
-        try {
-          const json = JSON.parse(data)
-          done(json.version || null)
-        } catch {
-          done(null)
-        }
-      })
-    }).on('error', () => {
-      done(null)
-    })
-  })
-}
-
-async function loadCache(directory: string): Promise<VersionCache | null> {
-  try {
-    const cachePath = path.join(directory, '.opencode', CACHE_FILE)
-    const data = await fs.readFile(cachePath, 'utf8')
-    return JSON.parse(data)
-  } catch {
-    return null
-  }
-}
-
-async function saveCache(directory: string, cache: VersionCache): Promise<void> {
-  try {
-    const cachePath = path.join(directory, '.opencode', CACHE_FILE)
-    await fs.writeFile(cachePath, JSON.stringify(cache))
-  } catch {}
-}
-
-function compareVersions(local: string, latest: string): number {
-  // Strip pre-release suffix (e.g., "4.38.1-beta.1" → "4.38.1")
-  const strip = (v: string) => v.replace(/-.*$/, '')
-  const localParts = strip(local).split('.').map(Number)
-  const latestParts = strip(latest).split('.').map(Number)
-  
-  for (let i = 0; i < 3; i++) {
-    const l = localParts[i] || 0
-    const r = latestParts[i] || 0
-    if (l < r) return -1
-    if (l > r) return 1
-  }
-  return 0
-}
-
-// Fun update messages
-const UPDATE_MESSAGES = {
-  en: (local: string, latest: string) => `🚀 Update available! ${local} → ${latest}. Run: npx @comfanion/workflow update`,
-  uk: (local: string, latest: string) => `🚀 Є оновлення! ${local} → ${latest}. Виконай: npx @comfanion/workflow update`,
-  ru: (local: string, latest: string) => `🚀 Доступно обновление! ${local} → ${latest}. Выполни: npx @comfanion/workflow update`,
-}
-
-async function getLanguage(directory: string): Promise<'en' | 'uk' | 'ru'> {
-  try {
-    const configPath = path.join(directory, '.opencode', 'config.yaml')
-    const config = await fs.readFile(configPath, 'utf8')
-    const match = config.match(/communication_language:\s*["']?(\w+)["']?/i)
-    const lang = match?.[1]?.toLowerCase()
-    if (lang === 'ukrainian' || lang === 'uk') return 'uk'
-    if (lang === 'russian' || lang === 'ru') return 'ru'
-  } catch {}
-  return 'en'
-}
-
-async function loadVersionCheckConfig(directory: string): Promise<{ enabled: boolean; checkInterval: number }> {
-  try {
-    const configPath = path.join(directory, '.opencode', 'config.yaml')
-    const content = await fs.readFile(configPath, 'utf8')
-    const section = content.match(/version_check:\s*\n([\s\S]*?)(?=\n[a-z_]+:|$)/i)
-    if (!section) return { enabled: true, checkInterval: 60 * 60 * 1000 }
-    const enabledMatch = section[1].match(/^\s+enabled:\s*(true|false)/m)
-    const intervalMatch = section[1].match(/^\s+check_interval:\s*(\d+)/m)
-    return {
-      enabled: enabledMatch ? enabledMatch[1] === 'true' : true,
-      checkInterval: intervalMatch ? parseInt(intervalMatch[1]) : 60 * 60 * 1000,
-    }
-  } catch {
-    return { enabled: true, checkInterval: 60 * 60 * 1000 }
-  }
-}
-
-export const VersionCheckPlugin: Plugin = async ({ directory, client }) => {
-  const vcConfig = await loadVersionCheckConfig(directory)
-  const CHECK_INTERVAL = vcConfig.checkInterval
-  
-  const toast = async (message: string, variant: 'info' | 'success' | 'error' = 'info') => {
-    try {
-      await client?.tui?.showToast?.({ body: { message, variant } })
-    } catch {}
-  }
-  
-  log(`Plugin loaded`)
-  
-  // Respect config enabled flag
-  if (!vcConfig.enabled) {
-    log(`Plugin DISABLED by config`)
-    return {
-      event: async () => {},
-    }
-  }
-  
-  // Run check after short delay (let TUI initialize)
-  setTimeout(async () => {
-    try {
-      // Check cache first
-      const cache = await loadCache(directory)
-      const now = Date.now()
-      
-      // Skip if checked recently
-      if (cache && (now - cache.lastCheck) < CHECK_INTERVAL) {
-        log(`Skipping check (cached ${Math.round((now - cache.lastCheck) / 1000 / 60)}min ago)`)
-        
-        // But still show toast if update was available
-        const localVersion = await getLocalVersion(directory)
-        if (localVersion && cache.latestVersion && compareVersions(localVersion, cache.latestVersion) < 0) {
-          const lang = await getLanguage(directory)
-          await toast(UPDATE_MESSAGES[lang](localVersion, cache.latestVersion), 'info')
-        }
-        return
-      }
-      
-      // Get versions
-      const localVersion = await getLocalVersion(directory)
-      if (!localVersion) {
-        log(`Could not determine local version`)
-        return
-      }
-      
-      log(`Local version: ${localVersion}`)
-      
-      const latestVersion = await getLatestVersion()
-      if (!latestVersion) {
-        log(`Could not fetch latest version from npm`)
-        return
-      }
-      
-      log(`Latest version: ${latestVersion}`)
-      
-      // Save to cache
-      await saveCache(directory, { lastCheck: now, latestVersion })
-      
-      // Compare and notify
-      if (compareVersions(localVersion, latestVersion) < 0) {
-        log(`Update available: ${localVersion} → ${latestVersion}`)
-        const lang = await getLanguage(directory)
-        await toast(UPDATE_MESSAGES[lang](localVersion, latestVersion), 'info')
-      } else {
-        log(`Up to date!`)
-      }
-    } catch (e) {
-      log(`Error: ${(e as Error).message}`)
-    }
-  }, 2000)
-  
-  return {
-    event: async () => {}, // No events needed
-  }
-}
-
-export default VersionCheckPlugin

package/src/opencode/tools/codeindex.ts

@@ -1,264 +0,0 @@
-/**
- * Code Index Status & Management Tool
- * 
- * Check indexing status and trigger re-indexing.
- * Uses LOCAL vectorizer - no npm calls needed.
- * 
- * Usage by model:
- *   codeindex({ action: "status" })
- *   codeindex({ action: "status", index: "docs" })
- *   codeindex({ action: "reindex", index: "code" })
- *   codeindex({ action: "list" })
- */
-
-import { tool } from "@opencode-ai/plugin"
-import path from "path"
-import fs from "fs/promises"
-
-// 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
-- "list" → List all available indexes with stats
-- "reindex" → Re-index files using LOCAL vectorizer (no npm needed)
-
-Available indexes:
-- "code" - Source code files (.js, .ts, .go, .py, etc.)
-- "docs" - Documentation files (.md, .txt, etc.)
-- "config" - Configuration files (.yaml, .json, etc.)
-
-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
-    const isInstalled = await fs.access(path.join(vectorizerDir, "node_modules"))
-      .then(() => true)
-      .catch(() => false)
-
-    if (!isInstalled) {
-      return `❌ Vectorizer not installed.
-
-To install, run in terminal:
-\`\`\`bash
-npx @comfanion/workflow vectorizer install
-\`\`\`
-
-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 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:\n`
-        output += `\`\`\`\n`
-        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
-    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_DESCRIPTIONS[indexName] || "Custom index"
-
-        return `## Index Status: "${indexName}"
-
-✅ **Vectorizer installed**
-✅ **Index active**
-
-**Description:** ${desc}
-**Files indexed:** ${fileCount}
-
-**Sample indexed files:**
-${sampleFiles.map(f => `- ${f}`).join("\n")}
-${fileCount > 5 ? `- ... and ${fileCount - 5} more` : ""}
-
-**Usage:**
-\`\`\`
-codesearch({ query: "your search query", index: "${indexName}" })
-\`\`\`
-
-To re-index:
-\`\`\`
-codeindex({ action: "reindex", index: "${indexName}" })
-\`\`\``
-
-      } catch {
-        return `## Index Status: "${indexName}"
-
-✅ **Vectorizer installed**
-⚠️ **Index "${indexName}" not created yet**
-
-To create this index:
-\`\`\`
-codeindex({ action: "reindex", index: "${indexName}" })
-\`\`\`
-
-Or with specific directory:
-\`\`\`
-codeindex({ action: "reindex", index: "${indexName}", dir: "src/" })
-\`\`\``
-      }
-    }
-
-    // REINDEX: Re-index using LOCAL vectorizer (no npm!)
-    if (args.action === "reindex") {
-      try {
-        // 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}
-**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:
-\`\`\`
-codesearch({ query: "your search query", index: "${indexName}" })
-\`\`\``
-
-      } catch (error: any) {
-        return `❌ Re-indexing failed: ${error.message}
-
-Make sure vectorizer is installed:
-\`\`\`bash
-npx @comfanion/workflow vectorizer install
-\`\`\``
-      }
-    }
-
-    return `Unknown action: ${args.action}. Use: status, list, or reindex`
-  },
-})

package/src/opencode/tools/search.ts

@@ -1,149 +0,0 @@
-/**
- * Semantic Code Search Tool
- * 
- * Allows the AI model to search the codebase using semantic similarity.
- * Uses local embeddings (all-MiniLM-L6-v2) and LanceDB vector store.
- * Supports multiple indexes: code, docs, config, or search all.
- * 
- * Usage by model:
- *   codesearch({ query: "authentication middleware", limit: 5 })
- *   codesearch({ query: "how to deploy", index: "docs" })
- *   codesearch({ query: "database config", index: "config" })
- *   codesearch({ query: "error handling", searchAll: true })
- * 
- * Prerequisites:
- *   npx @comfanion/workflow vectorizer install
- *   npx @comfanion/workflow index --index code
- *   npx @comfanion/workflow index --index docs
- */
-
-import { tool } from "@opencode-ai/plugin"
-import path from "path"
-import fs from "fs/promises"
-
-export default tool({
-  description: `Search the codebase semantically. Use this to find relevant code snippets, functions, or files based on meaning, not just text matching.
-
-Available indexes:
-- "code" (default) - Source code files (*.js, *.ts, *.py, *.go, etc.)
-- "docs" - Documentation files (*.md, *.txt, etc.)
-- "config" - Configuration files (*.yaml, *.json, etc.)
-- searchAll: true - Search across all indexes
-
-Examples:
-- "authentication logic" → finds auth-related code
-- "database connection handling" → finds DB setup code  
-- "how to deploy" with index: "docs" → finds deployment docs
-- "API keys" with index: "config" → finds config with API settings
-
-Prerequisites: Run 'npx @comfanion/workflow index --index <name>' first.`,
-
-  args: {
-    query: tool.schema.string().describe("Semantic search query describing what you're looking for"),
-    index: tool.schema.string().optional().default("code").describe("Index to search: code, docs, config, or custom name"),
-    limit: tool.schema.number().optional().default(10).describe("Number of results to return (default: 10)"),
-    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)"),
-    includeArchived: tool.schema.boolean().optional().default(false).describe("Include archived files in results (default: false). Files are archived if in /archive/ folder or have 'archived: true' in frontmatter."),
-  },
-
-  async execute(args, context) {
-    const projectRoot = process.cwd()
-    const vectorizerDir = path.join(projectRoot, ".opencode", "vectorizer")
-    const vectorizerModule = path.join(vectorizerDir, "index.js")
-
-    // Check if vectorizer is installed
-    try {
-      await fs.access(path.join(vectorizerDir, "node_modules"))
-    } catch {
-      return `❌ Vectorizer not installed. Run: npx @comfanion/workflow vectorizer install`
-    }
-
-    try {
-      // Dynamic import of the vectorizer
-      const { CodebaseIndexer } = await import(`file://${vectorizerModule}`)
-      
-      let allResults: any[] = []
-      const limit = args.limit || 10
-      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()
-        const indexes = await tempIndexer.listIndexes()
-
-        if (indexes.length === 0) {
-          return `❌ No indexes found. Run: npx @comfanion/workflow index --index code`
-        }
-
-        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, args.includeArchived)
-          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
-        allResults.sort((a, b) => (a._distance || 0) - (b._distance || 0))
-        allResults = allResults.slice(0, limit)
-
-      } else {
-        // Search specific index
-        const hashesFile = path.join(projectRoot, ".opencode", "vectors", indexName, "hashes.json")
-        try {
-          await fs.access(hashesFile)
-        } catch {
-          return `❌ Index "${indexName}" not found. Run: npx @comfanion/workflow index --index ${indexName}`
-        }
-
-        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) {
-        const scope = args.searchAll ? "any index" : `index "${indexName}"`
-        return `No results found in ${scope} for: "${args.query}"\n\nTry:\n- Different keywords\n- Re-index with: npx @comfanion/workflow index --index ${indexName} --force`
-      }
-
-      // Format results for the model
-      const scope = args.searchAll ? "all indexes" : `index "${indexName}"`
-      let output = `## Search Results for: "${args.query}" (${scope})\n\n`
-      
-      for (let i = 0; i < allResults.length; i++) {
-        const r = allResults[i]
-        const score = r._distance ? (1 - r._distance).toFixed(3) : "N/A"
-        const indexLabel = args.searchAll ? ` [${r._index}]` : ""
-        
-        output += `### ${i + 1}. ${r.file}${indexLabel}\n`
-        output += `**Relevance:** ${score}\n\n`
-        output += "```\n"
-        // Truncate long content
-        const content = r.content.length > 500 
-          ? r.content.substring(0, 500) + "\n... (truncated)"
-          : r.content
-        output += content
-        output += "\n```\n\n"
-      }
-
-      output += `---\n*Found ${allResults.length} results. Use Read tool to see full files.*`
-
-      return output
-
-    } catch (error: any) {
-      return `❌ Search failed: ${error.message}\n\nTry re-indexing: npx @comfanion/workflow index --index ${args.index || "code"} --force`
-    }
-  },
-})