@codebakers/cli 3.3.17 → 3.4.0

package/src/mcp/server.ts

@@ -68,6 +68,7 @@ class CodeBakersServer {
   private pendingUpdate: { current: string; latest: string } | null = null;
   private lastUpdateCheck = 0;
   private updateCheckInterval = 60 * 60 * 1000; // Check every hour
+  private currentSessionToken: string | null = null; // v6.0: Server-side enforcement session
 
   constructor() {
     this.apiKey = getApiKey();
@@ -896,6 +897,31 @@ class CodeBakersServer {
             required: ['feature'],
           },
         },
+        {
+          name: 'discover_patterns',
+          description:
+            'MANDATORY: Call this BEFORE writing or modifying ANY code. Searches codebase for similar implementations and identifies relevant patterns. Returns existing code patterns you MUST follow. You are NOT ALLOWED to write code without calling this first.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              task: {
+                type: 'string',
+                description: 'What you are about to do (e.g., "add signup form", "fix auth bug", "create payment endpoint")',
+              },
+              files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Files you plan to create or modify',
+              },
+              keywords: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Keywords to search for in codebase (e.g., ["auth", "login", "user"])',
+              },
+            },
+            required: ['task'],
+          },
+        },
         {
           name: 'report_pattern_gap',
           description:
@@ -1619,6 +1645,9 @@ class CodeBakersServer {
         case 'validate_complete':
           return this.handleValidateComplete(args as { feature: string; files?: string[] });
 
+        case 'discover_patterns':
+          return this.handleDiscoverPatterns(args as { task: string; files?: string[]; keywords?: string[] });
+
         case 'report_pattern_gap':
           return this.handleReportPatternGap(args as { category: string; request: string; context?: string; handledWith?: string; wasSuccessful?: boolean });
 
@@ -3795,18 +3824,32 @@ Just describe what you want to build! I'll automatically:
   }
 
   /**
-   * MANDATORY: Validate that a feature is complete before AI can say "done"
-   * Checks: tests exist, tests pass, TypeScript compiles
+   * MANDATORY: Validate that a feature is complete before AI can say "done" (v6.0 Server-Side)
+   * Runs local checks (tests, TypeScript), then validates with server
    */
-  private handleValidateComplete(args: { feature: string; files?: string[] }) {
+  private async handleValidateComplete(args: { feature: string; files?: string[] }) {
     const { feature, files = [] } = args;
     const cwd = process.cwd();
-    const issues: string[] = [];
     let testsExist = false;
     let testsPass = false;
     let typescriptPass = false;
+    const testsWritten: string[] = [];
 
-    // Step 1: Check if test files exist
+    // Step 1: Get session token (from memory or state file)
+    let sessionToken = this.currentSessionToken;
+    if (!sessionToken) {
+      try {
+        const stateFile = path.join(cwd, '.codebakers.json');
+        if (fs.existsSync(stateFile)) {
+          const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+          sessionToken = (state.currentSessionToken as string | undefined) || null;
+        }
+      } catch {
+        // Ignore errors
+      }
+    }
+
+    // Step 2: Check if test files exist and find them
     try {
       const testDirs = ['tests', 'test', '__tests__', 'src/__tests__', 'src/tests'];
       const testExtensions = ['.test.ts', '.test.tsx', '.spec.ts', '.spec.tsx'];
@@ -3818,31 +3861,31 @@ Just describe what you want to build! I'll automatically:
             .filter((f: string | Buffer) => testExtensions.some(ext => String(f).endsWith(ext)));
           if (testFiles.length > 0) {
             testsExist = true;
-            break;
+            testsWritten.push(...testFiles.map(f => path.join(dir, String(f))));
           }
         }
       }
 
       // Also check for test files adjacent to source files
-      if (!testsExist && files.length > 0) {
+      if (files.length > 0) {
         for (const file of files) {
           const testFile = file.replace(/\.tsx?$/, '.test.ts');
           const specFile = file.replace(/\.tsx?$/, '.spec.ts');
-          if (fs.existsSync(path.join(cwd, testFile)) || fs.existsSync(path.join(cwd, specFile))) {
+          if (fs.existsSync(path.join(cwd, testFile))) {
             testsExist = true;
-            break;
+            testsWritten.push(testFile);
+          }
+          if (fs.existsSync(path.join(cwd, specFile))) {
+            testsExist = true;
+            testsWritten.push(specFile);
           }
         }
       }
-
-      if (!testsExist) {
-        issues.push('NO_TESTS: No test files found. You MUST write tests before completing this feature.');
-      }
     } catch {
-      issues.push('NO_TESTS: Could not verify test files exist.');
+      // Ignore errors
     }
 
-    // Step 2: Run tests
+    // Step 3: Run tests locally
     if (testsExist) {
       try {
         let testCommand = 'npm test';
@@ -3862,13 +3905,12 @@ Just describe what you want to build! I'll automatically:
           stdio: ['pipe', 'pipe', 'pipe'],
         });
         testsPass = true;
-      } catch (error) {
-        const execError = error as { stderr?: string };
-        issues.push(`TESTS_FAIL: Tests are failing. Fix them before completing.\n${execError.stderr?.slice(0, 500) || ''}`);
+      } catch {
+        testsPass = false;
       }
     }
 
-    // Step 3: Run TypeScript check
+    // Step 4: Run TypeScript check locally
     try {
       execSync('npx tsc --noEmit', {
         cwd,
@@ -3877,42 +3919,381 @@ Just describe what you want to build! I'll automatically:
         stdio: ['pipe', 'pipe', 'pipe'],
       });
       typescriptPass = true;
-    } catch (error) {
-      const execError = error as { stdout?: string; stderr?: string };
-      const output = execError.stdout || execError.stderr || '';
-      issues.push(`TYPESCRIPT_ERRORS: TypeScript compilation failed.\n${output.slice(0, 500)}`);
+    } catch {
+      typescriptPass = false;
     }
 
-    // Generate response
-    const valid = testsExist && testsPass && typescriptPass;
+    // Step 5: Call server API for validation
+    if (sessionToken) {
+      try {
+        const response = await fetch(`${this.apiUrl}/api/patterns/validate`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            ...this.getAuthHeaders(),
+          },
+          body: JSON.stringify({
+            sessionToken,
+            featureName: feature,
+            featureDescription: `Feature implementation for: ${feature}`,
+            filesModified: files,
+            testsWritten,
+            testsRun: testsExist,
+            testsPassed: testsPass,
+            typescriptPassed: typescriptPass,
+          }),
+        });
+
+        const result = await response.json();
 
-    let response = `# ✅ Feature Validation: ${feature}\n\n`;
-    response += `| Check | Status |\n|-------|--------|\n`;
-    response += `| Tests exist | ${testsExist ? '✅ PASS' : '❌ FAIL'} |\n`;
-    response += `| Tests pass | ${testsPass ? '✅ PASS' : testsExist ? '❌ FAIL' : '⏭️ SKIP'} |\n`;
-    response += `| TypeScript compiles | ${typescriptPass ? '✅ PASS' : '❌ FAIL'} |\n\n`;
+        // Save validation result for pre-commit hook
+        try {
+          const stateFile = path.join(cwd, '.codebakers.json');
+          let state: Record<string, unknown> = {};
+          if (fs.existsSync(stateFile)) {
+            state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+          }
 
-    if (valid) {
-      response += `## ✅ Feature is COMPLETE\n\n`;
-      response += `All validation checks passed. You may now mark this feature as done.\n`;
+          // Save validation details for pre-commit hook
+          state.lastValidation = {
+            passed: result.passed,
+            timestamp: new Date().toISOString(),
+            feature,
+            issues: result.issues || [],
+            testsExist,
+            testsPassed: testsPass,
+            typescriptPassed: typescriptPass,
+          };
+
+          // Clear session token only if validation passed
+          if (result.passed) {
+            this.currentSessionToken = null;
+            delete state.currentSessionToken;
+            state.lastValidationAt = new Date().toISOString();
+            state.lastValidationPassed = true;
+          }
+
+          fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+        } catch {
+          // Ignore errors
+        }
+
+        // Generate response from server result
+        let responseText = `# ✅ Feature Validation: ${feature}\n\n`;
+        responseText += `## Server Validation Result\n\n`;
+        responseText += `**Status:** ${result.passed ? '✅ PASSED' : '❌ FAILED'}\n\n`;
+
+        if (result.issues && result.issues.length > 0) {
+          responseText += `### Issues:\n\n`;
+          for (const issue of result.issues) {
+            const icon = issue.severity === 'error' ? '❌' : '⚠️';
+            responseText += `${icon} **${issue.type}**: ${issue.message}\n\n`;
+          }
+        }
+
+        responseText += `### Local Checks:\n\n`;
+        responseText += `| Check | Status |\n|-------|--------|\n`;
+        responseText += `| Tests exist | ${testsExist ? '✅ PASS' : '❌ FAIL'} |\n`;
+        responseText += `| Tests pass | ${testsPass ? '✅ PASS' : testsExist ? '❌ FAIL' : '⏭️ SKIP'} |\n`;
+        responseText += `| TypeScript compiles | ${typescriptPass ? '✅ PASS' : '❌ FAIL'} |\n\n`;
+
+        if (result.passed) {
+          responseText += `## ✅ Feature is COMPLETE\n\n`;
+          responseText += `Server has recorded this completion. You may now mark this feature as done.\n`;
+        } else {
+          responseText += `## ❌ Feature is NOT COMPLETE\n\n`;
+          responseText += `**${result.nextSteps || 'Fix the issues above and try again.'}**\n`;
+        }
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: responseText,
+          }],
+          isError: !result.passed,
+        };
+      } catch (error) {
+        // Server unreachable - fall back to local validation
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        const valid = testsExist && testsPass && typescriptPass;
+
+        let responseText = `# ✅ Feature Validation: ${feature}\n\n`;
+        responseText += `## ⚠️ OFFLINE MODE - Server Unreachable\n\n`;
+        responseText += `Error: ${message}\n\n`;
+        responseText += `### Local Checks Only:\n\n`;
+        responseText += `| Check | Status |\n|-------|--------|\n`;
+        responseText += `| Tests exist | ${testsExist ? '✅ PASS' : '❌ FAIL'} |\n`;
+        responseText += `| Tests pass | ${testsPass ? '✅ PASS' : testsExist ? '❌ FAIL' : '⏭️ SKIP'} |\n`;
+        responseText += `| TypeScript compiles | ${typescriptPass ? '✅ PASS' : '❌ FAIL'} |\n\n`;
+        responseText += `**Note:** Server validation skipped due to connection error.\n`;
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: responseText,
+          }],
+          isError: !valid,
+        };
+      }
     } else {
-      response += `## ❌ Feature is NOT COMPLETE\n\n`;
-      response += `**You are NOT ALLOWED to say "done" or "complete" until all checks pass.**\n\n`;
-      response += `### Issues to fix:\n\n`;
-      for (const issue of issues) {
-        response += `- ${issue}\n\n`;
+      // No session token - cannot validate with server
+      let responseText = `# ❌ Feature Validation: ${feature}\n\n`;
+      responseText += `## ⛔ NO SESSION TOKEN\n\n`;
+      responseText += `You must call \`discover_patterns\` BEFORE writing code to get a session token.\n\n`;
+      responseText += `### Local Checks (not sufficient for completion):\n\n`;
+      responseText += `| Check | Status |\n|-------|--------|\n`;
+      responseText += `| Tests exist | ${testsExist ? '✅ PASS' : '❌ FAIL'} |\n`;
+      responseText += `| Tests pass | ${testsPass ? '✅ PASS' : testsExist ? '❌ FAIL' : '⏭️ SKIP'} |\n`;
+      responseText += `| TypeScript compiles | ${typescriptPass ? '✅ PASS' : '❌ FAIL'} |\n\n`;
+      responseText += `**You CANNOT complete this feature without a valid session.**\n`;
+      responseText += `Call \`discover_patterns\` first, then implement the feature, then call \`validate_complete\` again.`;
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: responseText,
+        }],
+        isError: true,
+      };
+    }
+  }
+
+  /**
+   * discover_patterns - START gate for pattern compliance (v6.0 Server-Side)
+   * MUST be called before writing any code
+   * Calls server API to get patterns and creates enforcement session
+   */
+  private async handleDiscoverPatterns(args: { task: string; files?: string[]; keywords?: string[] }) {
+    const { task, files = [], keywords = [] } = args;
+    const cwd = process.cwd();
+
+    // Generate project hash for context
+    let projectHash: string | undefined;
+    let projectName: string | undefined;
+    try {
+      const pkgPath = path.join(cwd, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        projectName = pkg.name || path.basename(cwd);
+      } else {
+        projectName = path.basename(cwd);
       }
-      response += `---\n\n**Fix these issues and call \`validate_complete\` again.**`;
+      // Simple hash of project path
+      projectHash = Buffer.from(cwd).toString('base64').slice(0, 32);
+    } catch {
+      projectName = path.basename(cwd);
     }
 
-    return {
-      content: [{
-        type: 'text' as const,
-        text: response,
-      }],
-      // Return structured data for programmatic use
-      isError: !valid,
-    };
+    try {
+      // Call server API to discover patterns and create enforcement session
+      const response = await fetch(`${this.apiUrl}/api/patterns/discover`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...this.getAuthHeaders(),
+        },
+        body: JSON.stringify({
+          task,
+          files,
+          keywords,
+          projectHash,
+          projectName,
+        }),
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.error || 'Server returned an error');
+      }
+
+      const result = await response.json();
+
+      // Store session token for validate_complete
+      this.currentSessionToken = result.sessionToken;
+
+      // Also store in local state file for persistence across restarts
+      try {
+        const stateFile = path.join(cwd, '.codebakers.json');
+        let state: Record<string, unknown> = {};
+        if (fs.existsSync(stateFile)) {
+          state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+        }
+        state.currentSessionToken = result.sessionToken;
+        state.lastDiscoveryTask = task;
+        state.lastDiscoveryAt = new Date().toISOString();
+        // Session expires in 2 hours (server default)
+        state.sessionExpiresAt = result.expiresAt || new Date(Date.now() + 2 * 60 * 60 * 1000).toISOString();
+        // Clear any previous validation (new session = new work)
+        delete state.lastValidation;
+        fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+      } catch {
+        // Ignore state file errors
+      }
+
+      // Generate response with ALL instructions from server
+      let responseText = `# 🔍 Pattern Discovery: ${task}\n\n`;
+      responseText += `## ⛔ SERVER-ENFORCED SESSION ACTIVE\n\n`;
+      responseText += `**Session Token:** \`${result.sessionToken}\`\n\n`;
+      responseText += `---\n\n`;
+
+      // Section 1: Patterns from server
+      if (result.patterns && result.patterns.length > 0) {
+        responseText += `## 📦 MANDATORY PATTERNS\n\n`;
+        responseText += `You MUST follow these patterns in your code:\n\n`;
+        for (const pattern of result.patterns) {
+          responseText += `### ${pattern.name}\n\n`;
+          responseText += `**Relevance:** ${pattern.relevance}\n\n`;
+          responseText += `\`\`\`typescript\n${pattern.content || ''}\n\`\`\`\n\n`;
+        }
+      }
+
+      // Section 2: Test Requirements (ALL from server, not local file)
+      responseText += `---\n\n`;
+      responseText += `## 🧪 MANDATORY: TESTS REQUIRED\n\n`;
+      responseText += `**You MUST write and run tests. Validation will FAIL without them.**\n\n`;
+      responseText += `### Test Frameworks\n\n`;
+      responseText += `| Type | Framework | Command |\n`;
+      responseText += `|------|-----------|--------|\n`;
+      responseText += `| Unit tests | Vitest | \`npm run test\` or \`npx vitest run\` |\n`;
+      responseText += `| E2E tests | Playwright | \`npx playwright test\` |\n\n`;
+      responseText += `### Test File Locations\n\n`;
+      responseText += `| Code Type | Test Location |\n`;
+      responseText += `|-----------|---------------|\n`;
+      responseText += `| API routes | \`tests/api/[route].test.ts\` |\n`;
+      responseText += `| Components | \`[component].test.tsx\` |\n`;
+      responseText += `| Services | \`tests/services/[service].test.ts\` |\n`;
+      responseText += `| E2E flows | \`e2e/[feature].spec.ts\` |\n\n`;
+      responseText += `### Minimum Test Template\n\n`;
+      responseText += `\`\`\`typescript\n`;
+      responseText += `// Vitest unit test\n`;
+      responseText += `import { describe, it, expect } from 'vitest';\n\n`;
+      responseText += `describe('FeatureName', () => {\n`;
+      responseText += `  it('should handle happy path', () => {\n`;
+      responseText += `    // Test success case\n`;
+      responseText += `  });\n\n`;
+      responseText += `  it('should handle errors', () => {\n`;
+      responseText += `    // Test error case\n`;
+      responseText += `  });\n`;
+      responseText += `});\n`;
+      responseText += `\`\`\`\n\n`;
+
+      // Section 3: Workflow
+      responseText += `---\n\n`;
+      responseText += `## 📋 REQUIRED WORKFLOW\n\n`;
+      responseText += `1. ✅ **Read patterns above** - they are MANDATORY\n`;
+      responseText += `2. ✅ **Write feature code** following the patterns\n`;
+      responseText += `3. ✅ **Write test file(s)** - include happy path + error cases\n`;
+      responseText += `4. ✅ **Run tests**: \`npm run test\`\n`;
+      responseText += `5. ✅ **Fix TypeScript errors**: \`npx tsc --noEmit\`\n`;
+      responseText += `6. ✅ **Call \`validate_complete\`** before saying "done"\n\n`;
+
+      // Section 4: Validation
+      responseText += `---\n\n`;
+      responseText += `## ✅ BEFORE SAYING "DONE"\n\n`;
+      responseText += `You MUST call the \`validate_complete\` MCP tool:\n\n`;
+      responseText += `\`\`\`\n`;
+      responseText += `Tool: validate_complete\n`;
+      responseText += `Args: { feature: "${task}", files: ["list of files you modified"] }\n`;
+      responseText += `\`\`\`\n\n`;
+      responseText += `This tool will:\n`;
+      responseText += `- Verify you called discover_patterns (server checks)\n`;
+      responseText += `- Check that test files exist\n`;
+      responseText += `- Run \`npm test\` and verify tests pass\n`;
+      responseText += `- Run TypeScript check\n`;
+      responseText += `- Report PASS or FAIL from server\n\n`;
+      responseText += `**You CANNOT mark this feature complete without calling validate_complete.**\n\n`;
+
+      // Section 5: Rules
+      responseText += `---\n\n`;
+      responseText += `## ⚠️ RULES (SERVER-ENFORCED)\n\n`;
+      responseText += `1. You CANNOT skip these patterns - server tracks compliance\n`;
+      responseText += `2. You CANNOT say "done" without validate_complete passing\n`;
+      responseText += `3. Tests are MANDATORY - validation fails without them\n`;
+      responseText += `4. TypeScript must compile - validation fails on errors\n`;
+      responseText += `5. Pre-commit hook blocks commits without passed validation\n\n`;
+      responseText += `**Server is tracking this session. Compliance is enforced.**`;
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: responseText,
+        }],
+      };
+    } catch (error) {
+      // Fallback to local-only mode if server is unreachable
+      const message = error instanceof Error ? error.message : 'Unknown error';
+
+      // Generate local patterns as fallback
+      const taskKeywords = this.extractKeywords(task);
+      const allKeywords = [...new Set([...keywords, ...taskKeywords])];
+
+      const patternMap: Record<string, string[]> = {
+        'auth': ['02-auth.md'], 'login': ['02-auth.md'], 'payment': ['05-payments.md'],
+        'stripe': ['05-payments.md'], 'database': ['01-database.md'], 'api': ['03-api.md'],
+        'form': ['04-frontend.md'], 'component': ['04-frontend.md'], 'test': ['08-testing.md'],
+      };
+
+      const patterns: string[] = ['00-core.md'];
+      for (const keyword of allKeywords) {
+        const lowerKeyword = keyword.toLowerCase();
+        for (const [key, patternFiles] of Object.entries(patternMap)) {
+          if (lowerKeyword.includes(key)) patterns.push(...patternFiles);
+        }
+      }
+      const uniquePatterns = [...new Set(patterns)];
+
+      let responseText = `# 🔍 Pattern Discovery: ${task}\n\n`;
+      responseText += `## ⚠️ OFFLINE MODE - Server Unreachable\n\n`;
+      responseText += `Error: ${message}\n\n`;
+      responseText += `**Using local pattern suggestions (not enforced):**\n\n`;
+      for (const p of uniquePatterns) {
+        responseText += `- \`${p}\`\n`;
+      }
+      responseText += `\n**Note:** Without server connection, enforcement is not active.\n`;
+      responseText += `Validation will also be limited to local checks only.`;
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: responseText,
+        }],
+      };
+    }
+  }
+
+  /**
+   * Extract keywords from a task description
+   */
+  private extractKeywords(task: string): string[] {
+    const words = task.toLowerCase()
+      .replace(/[^a-z0-9\s]/g, ' ')
+      .split(/\s+/)
+      .filter(w => w.length > 2);
+
+    // Filter out common words
+    const stopWords = ['the', 'and', 'for', 'add', 'fix', 'create', 'make', 'build', 'implement', 'update', 'modify', 'change', 'new', 'with', 'from', 'this', 'that'];
+    return words.filter(w => !stopWords.includes(w));
+  }
+
+  /**
+   * Find files recursively with given extensions
+   */
+  private findFilesRecursive(dir: string, extensions: string[]): string[] {
+    const results: string[] = [];
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+          results.push(...this.findFilesRecursive(fullPath, extensions));
+        } else if (entry.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
+          results.push(fullPath);
+        }
+      }
+    } catch {
+      // Ignore errors
+    }
+    return results;
   }
 
   private async handleReportPatternGap(args: { category: string; request: string; context?: string; handledWith?: string; wasSuccessful?: boolean }) {