@comfanion/workflow 4.39.0 → 4.39.2

package/bin/cli.js

@@ -54,7 +54,6 @@ program
   .option('--tdd', 'Use TDD methodology')
   .option('--stub', 'Use STUB methodology')
   .option('--full', 'Create full repo structure')
-  .option('--vectorizer', 'Install vectorizer for semantic code search')
   .action(async (options) => {
     console.log(chalk.blue.bold(`\n🚀 OpenCode Workflow v${VERSION}\n`));
     
@@ -70,9 +69,6 @@ program
       jira_url: 'https://your-domain.atlassian.net',
       jira_project: 'PROJ',
       create_repo_structure: false,
-      vectorizer_enabled: true,
-      vectorizer_auto_index: true,
-      vectorizer_model: 'Xenova/all-MiniLM-L6-v2',
       project_name: path.basename(process.cwd())
     };
     
@@ -99,19 +95,6 @@ program
           if (jiraUrlMatch) config.jira_url = jiraUrlMatch[1];
           if (jiraProjMatch) config.jira_project = jiraProjMatch[1];
           
-          // Parse vectorizer settings from vectorizer.yaml if exists
-          const vecPath = path.join(targetDir, 'vectorizer.yaml');
-          if (await fs.pathExists(vecPath)) {
-            const vecContent = await fs.readFile(vecPath, 'utf8');
-            const vEnabledMatch = vecContent.match(/enabled:\s*(true|false)/);
-            const vAutoMatch = vecContent.match(/auto_index:\s*(true|false)/);
-            const vModelMatch = vecContent.match(/model:\s*["']?([^"'\n]+)["']?/);
-            
-            if (vEnabledMatch) config.vectorizer_enabled = vEnabledMatch[1] === 'true';
-            if (vAutoMatch) config.vectorizer_auto_index = vAutoMatch[1] === 'true';
-            if (vModelMatch) config.vectorizer_model = vModelMatch[1].trim();
-          }
-          
           isUpdate = true;
         } catch (e) {
           // Could not parse, use defaults
@@ -199,40 +182,6 @@ program
           message: 'Create full repository structure (README, CONTRIBUTING, .gitignore, docs/)?',
           default: options.full || false
         },
-        {
-          type: 'confirm',
-          name: 'vectorizer_enabled',
-          message: 'Enable semantic code search (vectorizer)?',
-          default: true
-        },
-        {
-          type: 'list',
-          name: 'vectorizer_model',
-          message: 'Embedding model for semantic search:',
-          when: (answers) => answers.vectorizer_enabled,
-          choices: [
-            { 
-              name: 'MiniLM-L6 (Fast)    - ~10 files/10sec, 384 dims, good quality', 
-              value: 'Xenova/all-MiniLM-L6-v2' 
-            },
-            { 
-              name: 'BGE-small (Balanced) - ~9 files/10sec, 384 dims, better quality', 
-              value: 'Xenova/bge-small-en-v1.5' 
-            },
-            { 
-              name: 'BGE-base (Quality)   - ~3 files/10sec, 768 dims, best quality', 
-              value: 'Xenova/bge-base-en-v1.5' 
-            }
-          ],
-          default: config.vectorizer_model
-        },
-        {
-          type: 'confirm',
-          name: 'vectorizer_auto_index',
-          message: 'Enable auto-indexing? (reindex files on save)',
-          when: (answers) => answers.vectorizer_enabled,
-          default: true
-        },
         {
           type: 'checkbox',
           name: 'mcp_servers',
@@ -259,7 +208,6 @@ program
       if (options.stub) config.methodology = 'stub';
       if (options.jira) config.jira_enabled = true;
       if (options.full) config.create_repo_structure = true;
-      if (options.vectorizer) config.install_vectorizer = true;
     }
 
     const spinner = ora('Initializing OpenCode Workflow...').start();
@@ -324,7 +272,6 @@ program
       // Update config.yaml with user values
       spinner.text = 'Configuring...';
       const configPath = path.join(targetDir, 'config.yaml');
-      const vecPath = path.join(targetDir, 'vectorizer.yaml');
       let configContent;
       
       // If we had existing config, use it as base (preserves comments and formatting)
@@ -354,19 +301,6 @@ program
       
       await fs.writeFile(configPath, configContent);
 
-      // Update vectorizer.yaml
-      if (await fs.pathExists(vecPath)) {
-        let vecContent = await fs.readFile(vecPath, 'utf8');
-        vecContent = vecContent
-          .replace(/(enabled:)\s*(true|false)/, `$1 ${config.vectorizer_enabled}`)
-          .replace(/(auto_index:)\s*(true|false)/, `$1 ${config.vectorizer_auto_index}`);
-        
-        if (config.vectorizer_model) {
-          vecContent = vecContent.replace(/(model:)\s*["']?[^"'\n]+["']?/, `$1 "${config.vectorizer_model}"`);
-        }
-        await fs.writeFile(vecPath, vecContent);
-      }
-      
       // Create docs structure (always)
       spinner.text = 'Creating docs structure...';
       await fs.ensureDir(path.join(process.cwd(), 'docs'));
@@ -476,24 +410,10 @@ program
         console.log(chalk.gray('   Run manually: cd .opencode && bun install'));
       }
 
-      // Show what was done
-      const vectorizerInstalled = await fs.pathExists(path.join(targetDir, 'vectorizer', 'node_modules'));
-      if (vectorizerInstalled) {
-        console.log(chalk.green('✅ Vectorizer installed (fresh dependencies)'));
-      } else if (config.vectorizer_enabled) {
-        console.log(chalk.yellow('⚠️  Vectorizer: run `npx @comfanion/workflow vectorizer install`'));
-      } else {
-        console.log(chalk.gray('ℹ️  Vectorizer disabled (enable in config.yaml to use semantic search)'));
-      }
       if (hadVectors) {
         console.log(chalk.green('✅ Vector indexes preserved'));
       }
 
-      // Install vectorizer if requested and failed above
-      if (config.install_vectorizer && !vectorizerInstalled) {
-        await installVectorizer(targetDir);
-      }
-
       // Show summary
       console.log(chalk.yellow('\n📁 Created structure:'));
       console.log(`
@@ -559,9 +479,8 @@ program
 
 program
   .command('update')
-  .description('Update .opencode/ to latest version (preserves config.yaml and vectorizer)')
+  .description('Update .opencode/ to latest version (preserves config.yaml and vector indexes)')
   .option('--no-backup', 'Skip creating backup')
-  .option('--vectorizer', 'Update/install vectorizer too')
   .action(async (options) => {
     const spinner = ora('Updating OpenCode Workflow...').start();
     
@@ -762,27 +681,25 @@ program
       console.log(chalk.gray('  ○  Jira credentials not set'));
     }
     
-    // Check Vectorizer
-    console.log(chalk.cyan('\nVectorizer (semantic search):'));
-    const vectorsExist = await fs.pathExists(path.join(process.cwd(), '.opencode', 'vectors', 'code', 'hashes.json'));
-    
-    // Check vectorizer config
-    let vectorizerEnabled = true;
-    let autoIndexEnabled = true;
+    // Check Semantic Search plugin
+    console.log(chalk.cyan('\nSemantic search (@comfanion/usethis_search):'));
     try {
-      const vecConfigContent = await fs.readFile(path.join(process.cwd(), '.opencode/vectorizer.yaml'), 'utf8');
-      const vecEnabledMatch = vecConfigContent.match(/enabled:\s*(true|false)/);
-      const autoIndexMatch = vecConfigContent.match(/auto_index:\s*(true|false)/);
-      if (vecEnabledMatch) vectorizerEnabled = vecEnabledMatch[1] === 'true';
-      if (autoIndexMatch) autoIndexEnabled = autoIndexMatch[1] === 'true';
-    } catch {}
-    
-    console.log(vectorizerEnabled 
-      ? chalk.green('  ✅ Enabled in config')
-      : chalk.yellow('  ⚠️  Disabled in config'));
-    console.log(autoIndexEnabled
-      ? chalk.green('  ✅ Auto-index: ON')
-      : chalk.gray('  ○  Auto-index: OFF'));
+      const opcPath = path.join(process.cwd(), 'opencode.json');
+      if (await fs.pathExists(opcPath)) {
+        const opc = JSON.parse(await fs.readFile(opcPath, 'utf8'));
+        const plugins = opc.plugin || [];
+        if (plugins.includes('@comfanion/usethis_search')) {
+          console.log(chalk.green('  ✅ Plugin registered in opencode.json'));
+        } else {
+          console.log(chalk.yellow('  ⚠️  Plugin not in opencode.json (add "@comfanion/usethis_search" to plugin array)'));
+        }
+      } else {
+        console.log(chalk.gray('  ○  No opencode.json found'));
+      }
+    } catch {
+      console.log(chalk.gray('  ○  Could not check opencode.json'));
+    }
+    const vectorsExist = await fs.pathExists(path.join(process.cwd(), '.opencode', 'vectors', 'code', 'hashes.json'));
     if (vectorsExist) {
       try {
         const hashes = await fs.readJSON(path.join(process.cwd(), '.opencode', 'vectors', 'code', 'hashes.json'));
@@ -791,14 +708,7 @@ program
         console.log(chalk.gray('  ○  Not indexed yet'));
       }
     } else {
-      console.log(chalk.gray('  ○  Not indexed (will index on startup)'));
-    }
-    
-    // Check LSP env
-    if (process.env.OPENCODE_EXPERIMENTAL_LSP_TOOL === 'true' || process.env.OPENCODE_EXPERIMENTAL === 'true') {
-      console.log(chalk.green('  ✅ LSP tool enabled'));
-    } else {
-      console.log(chalk.gray('  ○  LSP tool disabled (set OPENCODE_EXPERIMENTAL_LSP_TOOL=true)'));
+      console.log(chalk.gray('  ○  Not indexed (will index on first startup with plugin)'));
     }
     
     console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.39.0",
+  "version": "4.39.2",
   "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": "4.39.0",
-  "buildDate": "2026-01-29T21:27:00.960Z",
+  "version": "4.39.2",
+  "buildDate": "2026-01-30T20:54:21.477Z",
   "files": [
     ".gitignore",
     "config.yaml",
@@ -13,6 +13,6 @@
     "mcp",
     "package.json",
     "opencode.json",
-    "vectorizer.yaml"
+    "dcp.jsonc"
   ]
 }

package/src/opencode/agents/analyst.md

@@ -40,7 +40,7 @@ permission:
 
 <activation critical="MANDATORY">
   <step n="1">Load persona from this agent file</step>
-  <step n="2">IMMEDIATE: store {user_name}, {communication_language} from .opencode/config.yaml</step>
+  <step n="2">IMMEDIATE: store {user_name}, {communication_language} from ../config.yaml</step>
   <step n="3">Greet user by {user_name}, communicate in {communication_language}</step>
   <step n="4">Understand user request and select appropriate skill</step>
 

package/src/opencode/agents/architect.md

@@ -46,7 +46,7 @@ permission:
 
 <activation critical="MANDATORY">
   <step n="1">Load persona from this agent file</step>
-  <step n="2">IMMEDIATE: store {user_name}, {communication_language} from .opencode/config.yaml</step>
+  <step n="2">IMMEDIATE: store {user_name}, {communication_language} from ../config.yaml</step>
   <step n="3">Greet user by {user_name}, communicate in {communication_language}</step>
   <step n="4">Understand user request and select appropriate skill</step>
   <step n="6">ALWAYS follow <workflow> before creating/modifying files</step>
@@ -103,28 +103,13 @@ permission:
   </phase>
   
   <size-awareness critical="MANDATORY">
-    BEFORE writing architecture, you MUST know project size:
-    
+    BEFORE writing architecture:
     1. Read PRD → "Project Classification" section
-    2. Note the size: TOY/SMALL/MEDIUM/LARGE/ENTERPRISE
-    3. Load skill: architecture-design → see size guidelines table
-    4. Adapt your architecture depth:
-       - TOY: 200-500 lines, simple diagram
-       - SMALL: 500-1000 lines, C4 Context+Container+Component
-       - MEDIUM: 1000-2000 lines, full C4 + break into MODULES
-       - LARGE: 2000-4000 lines, multiple files, DOMAINS
-       - ENTERPRISE: 4000+ lines, per-domain files
-    
-    REALITY CHECK: Most projects are TOY (30%) or SMALL (40%), MEDIUM+ (30%)
-    Default assumption: TOY/SMALL until proven otherwise
-    
-    Example:
-    - PRD says "TOY" → Write 350 lines, 3 components, NO modules
-    - PRD says "SMALL" → Write 700 lines, simple structure, NO modules
-    - PRD says "MEDIUM" → Write 1500 lines, 3 MODULES with Unit docs
+    2. Load skill: architecture-design → see size guidelines
+    3. Adapt depth: TOY (200-500 lines) → SMALL (500-1000) → MEDIUM (1000-2000, modules) → LARGE/ENTERPRISE (2000+, domains)
     
-    DON'T write 2000-line architecture for Tetris!
-    DON'T write 500-line architecture for E-commerce!
+    Default: TOY/SMALL until proven otherwise
+    Don't over-engineer small projects!
   </size-awareness>
 
   <phase name="2. Planning">
@@ -190,78 +175,19 @@ permission:
       └── entities/{name}.md    # Entities inside domain
 </documentation-structure>
 
-<lsp-architecture hint="Use LSP for architecture analysis - requires OPENCODE_EXPERIMENTAL_LSP_TOOL=true">
-  <use-case name="Module boundaries">
-    lsp documentSymbol src/modules/user/index.ts → See public API of module
-    lsp findReferences src/modules/user/types.ts:10:5 → Who depends on this type?
-  </use-case>
-  <use-case name="Dependency analysis">
-    lsp incomingCalls src/core/database.ts:20:10 → What modules use database?
-    lsp outgoingCalls src/api/handler.ts:15:5 → What does this handler depend on?
-  </use-case>
-  <use-case name="Interface contracts">
-    lsp goToImplementation src/interfaces/repository.ts:5:10 → Find all implementations
-    lsp workspaceSymbol "interface.*Repository" → Find all repository interfaces
-  </use-case>
-  <use-case name="Code structure review">
-    lsp documentSymbol src/domain/order.ts → Review domain model structure
-    lsp hover src/services/payment.ts:30:15 → Understand types and contracts
-  </use-case>
-</lsp-architecture>
-
-<codesearch-architecture hint="Semantic search with MULTI-INDEX for architecture analysis">
-  <check>codeindex({ action: "list" }) → See all indexes (code, docs, config)</check>
-
-  <indexes hint="Use different indexes for different architecture analysis">
-    <index name="code">Source code - patterns, implementations, boundaries</index>
-    <index name="docs">Documentation - ADRs, design docs, architecture decisions</index>
-    <index name="config">Configuration - infrastructure settings, feature flags</index>
-  </indexes>
-
-  <use-cases>
-    <use-case name="Discover patterns" index="code">
-      codesearch({ query: "repository pattern implementation", index: "code" })
-      codesearch({ query: "dependency injection", index: "code" })
-      codesearch({ query: "event handling", index: "code" })
-    </use-case>
-    <use-case name="Understand boundaries" index="code">
-      codesearch({ query: "domain entity validation", index: "code" })
-      codesearch({ query: "external API calls", index: "code" })
-      codesearch({ query: "database transactions", index: "code" })
-    </use-case>
-    <use-case name="Review decisions" index="docs">
-      codesearch({ query: "why we chose PostgreSQL", index: "docs" })
-      codesearch({ query: "authentication architecture", index: "docs" })
-      codesearch({ query: "caching strategy decision", index: "docs" })
-    </use-case>
-    <use-case name="Audit architecture" index="code">
-      codesearch({ query: "direct database access", index: "code" }) → Should be in repo only
-      codesearch({ query: "HTTP in domain", index: "code" }) → Layering violation
-      codesearch({ query: "business logic in handler", index: "code" }) → Should be in usecase
-    </use-case>
-    <use-case name="Infrastructure review" index="config">
-      codesearch({ query: "database connection pool", index: "config" })
-      codesearch({ query: "service timeouts", index: "config" })
-      codesearch({ query: "feature flags", index: "config" })
-    </use-case>
-  </use-cases>
-
-  <architecture-exploration-flow>
-    1. codeindex({ action: "list" }) → Check available indexes
-    2. codesearch({ query: "architecture overview", index: "docs" }) → Read existing docs
-    3. codesearch({ query: "module entry points", index: "code" }) → Find main files
-    4. codesearch({ query: "domain aggregates", index: "code" }) → Understand domain model
-    5. codesearch({ query: "repository interfaces", index: "code" }) → Data access patterns
-    6. codesearch({ query: "infrastructure config", index: "config" }) → See settings
-    7. lsp for detailed analysis of key files
-  </architecture-exploration-flow>
-
-  <cross-index-analysis hint="Combine indexes for full picture">
-    - Code + Docs: "How is authentication implemented?" (code) + "Why this approach?" (docs)
-    - Code + Config: "Database usage patterns" (code) + "Connection settings" (config)
-    - All: codesearch({ query: "caching", searchAll: true }) → Full picture
-  </cross-index-analysis>
-</codesearch-architecture>
+<code-intelligence hint="Use search and LSP for architecture analysis">
+  <search-workflow>
+    1. search({ query: "architecture overview", index: "docs" }) → Read existing docs
+    2. search({ query: "module patterns", index: "code" }) → Find implementations
+    3. Use LSP for detailed analysis: documentSymbol, findReferences, goToImplementation
+  </search-workflow>
+  
+  <common-searches>
+    - Patterns: search({ query: "repository pattern", index: "code" })
+    - Decisions: search({ query: "why chose PostgreSQL", index: "docs" })
+    - Violations: search({ query: "HTTP in domain", index: "code" })
+  </common-searches>
+</code-intelligence>
 
 </agent>
 

package/src/opencode/agents/coder.md

@@ -1,5 +1,5 @@
 ---
-description: "Fast Coder - Use for: quick implementation tasks, writing code, fixing bugs. Executes without asking questions."
+description: "Fast Coder - Use for: quick implementation tasks, writing code, fixing bugs. Give a brief description of what to do and where to find context (story file, source files, patterns). Do NOT give step-by-step instructions — coder reads context and figures out the rest."
 mode: subagent
 
 # Fast model for coding - no reasoning overhead
@@ -38,86 +38,34 @@ permission:
 
 <activation critical="MANDATORY">
   <step n="1">Receive task from parent agent or user</step>
-  <step n="2">Read relevant files mentioned in task</step>
-  <step n="3">Understand user request and select appropriate skill</step>
-  <step n="4">Find and use `docs/coding-standards/*.md` as coding standards</step>
-  <step n="5">Implement solution following project patterns</step>
-  <step n="6" hint="Prefer lint if project has linter configured">
-    If project has linter (eslint, biome, golint, ruff, etc.):
-    a) Run linter on modified files
-    b) If errors → fix them (max 3 attempts)
-    c) If still failing → report to parent agent
-  </step>
-  <step n="7" hint="Prefer test if tests exist for modified code">
-    If tests exist for modified code:
-    a) Run relevant tests
-    b) If failures → attempt to fix (max 2 attempts)
-    c) If still failing → report to parent agent
-  </step>
-  <step n="8">Report completion or errors</step>
+  <step n="2">Read files mentioned in task (story, source, patterns)</step>
+  <step n="3">Study existing code around the change point — understand conventions, imports, error handling</step>
+  <step n="4">Implement solution matching existing project style</step>
+  <step n="5">Run relevant tests if they exist. Fix failures (max 2 attempts). If still failing — output error</step>
+  <step n="6">Output: what was done, files changed, test results</step>
 
   <rules>
-    <r>DO NOT ask clarifying questions - execute or fail</r>
-    <r>DO NOT refactor beyond task scope</r>
-    <r>DO NOT add features not requested</r>
-    <r>Never implement anything not mapped to a specific task/subtask</r>
-    <r>Use skills if its needed</r>
+    <r>Think before coding, but no back-and-forth — make reasonable decisions and move</r>
+    <r>Stay within task scope, but make necessary decisions (naming, error handling, structure)</r>
+    <r>When writing new code — follow `docs/coding-standards/*.md` if present</r>
+    <r>Handle errors and edge cases — don't write only the happy path</r>
     <r>NEVER lie about tests being written or passing</r>
-    <r>If task is unclear, report what's missing and stop</r>
-    <r>Find and use `docs/coding-standards/*.md` as coding standards</r>
-    <r critical="MANDATORY">🔍 SEARCH FIRST: Call search() BEFORE glob when exploring codebase.
-       search({ query: "feature pattern", index: "code" }) → THEN glob if needed</r>
-    <r>Prefer running linter and fixing errors before reporting done</r>
-    <r>Prefer running tests and fixing failures before reporting done</r>
+    <r>If task is too vague to act on — output what's missing and stop</r>
+    <r critical="MANDATORY">SEARCH FIRST: Call search() BEFORE glob when exploring codebase</r>
   </rules>
 </activation>
 
 <persona>
   <role>Fast Implementation Specialist</role>
-  <identity>Quick executor for well-defined coding tasks. No planning, no questions - just code.</identity>
-  <communication_style>Minimal. Shows code, reports results. No explanations unless errors.</communication_style>
+  <identity>Efficient executor. Reads context, understands what's needed, writes quality code. Minimal talk, maximum output.</identity>
+  <communication_style>Minimal. Output: what was done, files changed, test results.</communication_style>
   <principles>
-    - Execute task as specified, no improvisation
-    - Follow existing code patterns in project
-    - Write minimal code that solves the problem
-    - Report errors immediately if blocked
+    - Understand context before writing code
+    - Follow existing patterns in the project
+    - Write clean code with proper error handling
+    - Stay within scope, make reasonable decisions on details
+    - Output errors immediately if blocked
   </principles>
 </persona>
 
-<when-to-use>
-  - Simple file creation/modification
-  - Bug fixes with clear reproduction
-  - Code following existing patterns
-  - Test writing for existing code
-  - Repetitive tasks across multiple files
-</when-to-use>
-
-<when-not-to-use>
-  - Architecture decisions (→ @architect)
-  - Complex multi-step features (→ @dev)
-  - Requirements unclear (→ @pm)
-  - New patterns needed (→ @dev)
-</when-not-to-use>
-
 </agent>
-
-## Quick Reference
-
-**Model:** Fast, no reasoning (execute, don't think)
-
-**What I Do:**
-- Quick code implementation
-- Bug fixes
-- Test writing
-- File operations
-- Pattern replication
-- Auto-fix linter errors (if linter configured)
-- Auto-fix test failures (if tests exist)
-
-**What I Don't Do:**
-- Planning or architecture
-- Clarifying questions
-- Scope expansion
-- Complex decisions
-
-**Invoke:** `@coder <task>` or let @dev delegate to me