codebakers 1.0.45 → 2.0.0

package/install.bat

@@ -0,0 +1,9 @@
+@echo off
+echo Installing CodeBakers CLI...
+npm install
+echo Building...
+npm run build
+echo Publishing to npm...
+npm publish
+echo Done! Now run: npm install -g codebakers
+pause

package/package.json

@@ -1,127 +1,83 @@
 {
   "name": "codebakers",
-  "displayName": "CodeBakers - Production Code, First Time",
-  "description": "Stop fixing AI mistakes. Cursor and Claude Code ignore your standards — CodeBakers enforces them. Save 20+ hours per project with production-ready code the first time.",
-  "version": "1.0.45",
-  "publisher": "codebakers",
-  "engines": {
-    "vscode": "^1.85.0"
+  "version": "2.0.0",
+  "description": "AI dev team that follows the rules. Build apps from anywhere with pattern enforcement.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "codebakers": "./dist/index.js",
+    "cb": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "test": "vitest",
+    "prepublishOnly": "npm run build"
   },
-  "categories": [
-    "Programming Languages",
-    "Snippets",
-    "Machine Learning",
-    "Other"
-  ],
   "keywords": [
+    "cli",
     "ai",
-    "claude",
-    "patterns",
-    "code generation",
-    "best practices",
-    "copilot"
+    "codebakers",
+    "code-generation",
+    "pattern-enforcement",
+    "developer-tools",
+    "automation",
+    "nextjs",
+    "supabase",
+    "vercel"
   ],
-  "icon": "media/icon.png",
-  "activationEvents": [
-    "*"
-  ],
-  "main": "./dist/extension.js",
-  "contributes": {
-    "commands": [
-      {
-        "command": "codebakers.openChat",
-        "title": "Open CodeBakers",
-        "category": "CodeBakers",
-        "icon": {
-          "light": "media/icon.svg",
-          "dark": "media/icon.svg"
-        }
-      },
-      {
-        "command": "codebakers.login",
-        "title": "Login to CodeBakers",
-        "category": "CodeBakers"
-      },
-      {
-        "command": "codebakers.logout",
-        "title": "Logout from CodeBakers",
-        "category": "CodeBakers"
-      },
-      {
-        "command": "codebakers.showPatterns",
-        "title": "Show Available Patterns",
-        "category": "CodeBakers"
-      },
-      {
-        "command": "codebakers.runAudit",
-        "title": "Run Code Audit",
-        "category": "CodeBakers"
-      }
-    ],
-    "menus": {
-      "editor/title": [
-        {
-          "command": "codebakers.openChat",
-          "group": "navigation"
-        }
-      ],
-      "commandPalette": [
-        {
-          "command": "codebakers.openChat"
-        },
-        {
-          "command": "codebakers.login"
-        },
-        {
-          "command": "codebakers.logout"
-        }
-      ]
-    },
-    "keybindings": [
-      {
-        "command": "codebakers.openChat",
-        "key": "ctrl+alt+c",
-        "mac": "cmd+alt+c"
-      }
-    ],
-    "configuration": {
-      "title": "CodeBakers",
-      "properties": {
-        "codebakers.apiEndpoint": {
-          "type": "string",
-          "default": "https://www.codebakers.ai",
-          "description": "CodeBakers API endpoint"
-        },
-        "codebakers.autoShowFooter": {
-          "type": "boolean",
-          "default": true,
-          "description": "Show CodeBakers footer after code generation"
-        }
-      }
-    }
-  },
-  "scripts": {
-    "vscode:prepublish": "npm run esbuild-base -- --production",
-    "compile": "npm run esbuild-base",
-    "esbuild-base": "node esbuild.js",
-    "esbuild-watch": "node esbuild.js --watch",
-    "watch": "npm run esbuild-watch",
-    "package": "vsce package",
-    "publish": "vsce publish"
+  "author": "BotMakers Inc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/botmakers/codebakers-cli"
   },
-  "devDependencies": {
-    "@types/node": "^20.10.0",
-    "@types/vscode": "^1.85.0",
-    "@vscode/vsce": "^2.22.0",
-    "esbuild": "^0.27.2",
-    "typescript": "^5.3.0"
+  "homepage": "https://codebakers.dev",
+  "engines": {
+    "node": ">=18.0.0"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.32.0",
-    "node-fetch": "^2.7.0"
+    "@anthropic-ai/sdk": "^0.32.1",
+    "@clack/prompts": "^0.7.0",
+    "@octokit/rest": "^21.0.0",
+    "@supabase/supabase-js": "^2.45.0",
+    "axios": "^1.7.0",
+    "boxen": "^8.0.0",
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "conf": "^13.0.0",
+    "dotenv": "^16.4.5",
+    "execa": "^9.3.0",
+    "fast-glob": "^3.3.2",
+    "figures": "^6.1.0",
+    "fs-extra": "^11.2.0",
+    "gradient-string": "^2.0.2",
+    "inquirer": "^10.0.0",
+    "node-fetch": "^3.3.2",
+    "open": "^10.1.0",
+    "ora": "^8.0.1",
+    "picocolors": "^1.0.1",
+    "simple-git": "^3.25.0",
+    "strip-ansi": "^7.1.0",
+    "terminal-link": "^3.0.0",
+    "update-notifier": "^7.1.0",
+    "which": "^4.0.0",
+    "zod": "^3.23.8"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/codebakers/codebakers-extension"
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/gradient-string": "^1.1.6",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.0.0",
+    "@types/update-notifier": "^6.0.8",
+    "@types/which": "^3.0.4",
+    "eslint": "^9.8.0",
+    "tsup": "^8.2.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
   }
 }

package/src/channels/discord.ts

@@ -0,0 +1,5 @@
+export class DiscordChannel {
+  async connect(token: string): Promise<void> {}
+  async disconnect(): Promise<void> {}
+  async sendMessage(channelId: string, message: string): Promise<void> {}
+}

package/src/channels/slack.ts

@@ -0,0 +1,5 @@
+export class SlackChannel {
+  async connect(token: string): Promise<void> {}
+  async disconnect(): Promise<void> {}
+  async sendMessage(channel: string, message: string): Promise<void> {}
+}

package/src/channels/sms.ts

@@ -0,0 +1,4 @@
+export class SMSChannel {
+  async connect(accountSid: string, authToken: string): Promise<void> {}
+  async sendMessage(to: string, message: string): Promise<void> {}
+}

package/src/channels/telegram.ts

@@ -0,0 +1,5 @@
+export class TelegramChannel {
+  async connect(token: string): Promise<void> {}
+  async disconnect(): Promise<void> {}
+  async sendMessage(chatId: string, message: string): Promise<void> {}
+}

package/src/channels/whatsapp.ts

@@ -0,0 +1,7 @@
+// WhatsApp Channel using Baileys
+export class WhatsAppChannel {
+  // Implementation would use @whiskeysockets/baileys
+  async connect(): Promise<void> {}
+  async disconnect(): Promise<void> {}
+  async sendMessage(to: string, message: string): Promise<void> {}
+}

package/src/commands/check.ts

@@ -0,0 +1,365 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import glob from 'fast-glob';
+import { Config } from '../utils/config.js';
+
+interface CheckOptions {
+  fix?: boolean;
+  watch?: boolean;
+}
+
+interface Violation {
+  file: string;
+  line: number;
+  rule: string;
+  message: string;
+  severity: 'error' | 'warning';
+  autoFixable: boolean;
+}
+
+interface CheckResult {
+  violations: Violation[];
+  filesChecked: number;
+  passed: boolean;
+}
+
+// Pattern rules extracted from your CLAUDE.md
+const RULES = [
+  {
+    id: 'no-any',
+    name: 'No any type',
+    description: 'Avoid using the "any" type',
+    severity: 'error' as const,
+    pattern: /:\s*any\b(?!\s*\=\>)/g,
+    message: 'Avoid using "any" type. Use proper TypeScript types.',
+    autoFixable: false,
+  },
+  {
+    id: 'no-ts-ignore',
+    name: 'No @ts-ignore',
+    description: 'Avoid using @ts-ignore',
+    severity: 'error' as const,
+    pattern: /@ts-ignore/g,
+    message: '@ts-ignore bypasses type checking. Fix the underlying issue.',
+    autoFixable: false,
+  },
+  {
+    id: 'no-console-log',
+    name: 'No console.log',
+    description: 'Remove debug console.log statements',
+    severity: 'warning' as const,
+    pattern: /console\.log\(/g,
+    message: 'Remove console.log before committing. Use proper logging.',
+    autoFixable: true,
+  },
+  {
+    id: 'no-todo',
+    name: 'No TODO comments',
+    description: 'Complete all TODOs before committing',
+    severity: 'warning' as const,
+    pattern: /\/\/\s*TODO:/gi,
+    message: 'Complete or remove TODO comments before committing.',
+    autoFixable: false,
+  },
+  {
+    id: 'no-fixme',
+    name: 'No FIXME comments',
+    description: 'Fix all FIXME issues before committing',
+    severity: 'error' as const,
+    pattern: /\/\/\s*FIXME:/gi,
+    message: 'Address FIXME issues before committing.',
+    autoFixable: false,
+  },
+  {
+    id: 'button-has-handler',
+    name: 'Button has onClick',
+    description: 'Buttons should have onClick handlers',
+    severity: 'error' as const,
+    pattern: /<Button[^>]*(?!onClick)[^>]*>/g,
+    message: 'Button must have an onClick handler.',
+    autoFixable: false,
+    validator: (content: string, match: RegExpExecArray) => {
+      // Check if onClick exists in the button
+      const buttonTag = match[0];
+      return !buttonTag.includes('onClick') && !buttonTag.includes('type="submit"');
+    },
+  },
+  {
+    id: 'async-has-try-catch',
+    name: 'Async has try/catch',
+    description: 'Async functions should have error handling',
+    severity: 'error' as const,
+    pattern: /async\s+(?:function\s+\w+|\([^)]*\)\s*=>|\w+\s*=\s*async\s*\([^)]*\)\s*=>)\s*\{[^}]*\}/g,
+    message: 'Async function should have try/catch error handling.',
+    autoFixable: false,
+    validator: (content: string, match: RegExpExecArray) => {
+      const funcBody = match[0];
+      return !funcBody.includes('try') && !funcBody.includes('catch');
+    },
+  },
+  {
+    id: 'no-hardcoded-secrets',
+    name: 'No hardcoded secrets',
+    description: 'Secrets should be in environment variables',
+    severity: 'error' as const,
+    pattern: /(sk_live_|sk_test_|pk_live_|pk_test_|api_key\s*=\s*['"][^'"]+['"])/gi,
+    message: 'Possible hardcoded secret. Use environment variables.',
+    autoFixable: false,
+  },
+  {
+    id: 'no-eval',
+    name: 'No eval()',
+    description: 'Never use eval() - security risk',
+    severity: 'error' as const,
+    pattern: /\beval\s*\(/g,
+    message: 'Never use eval(). It is a security vulnerability.',
+    autoFixable: false,
+  },
+  {
+    id: 'no-innerhtml',
+    name: 'No innerHTML',
+    description: 'Avoid direct innerHTML assignment',
+    severity: 'error' as const,
+    pattern: /\.innerHTML\s*=/g,
+    message: 'Avoid innerHTML. Use proper React rendering or DOMPurify.',
+    autoFixable: false,
+  },
+  {
+    id: 'loading-state',
+    name: 'Loading state in components',
+    description: 'Components with fetch should have loading states',
+    severity: 'warning' as const,
+    pattern: /useEffect\s*\([^)]*fetch\([^)]*\)/g,
+    message: 'Components fetching data should have loading states.',
+    autoFixable: false,
+    validator: (content: string) => {
+      return content.includes('fetch(') && 
+             !content.includes('isLoading') && 
+             !content.includes('loading') &&
+             !content.includes('isPending');
+    },
+  },
+  {
+    id: 'form-validation',
+    name: 'Form has validation',
+    description: 'Forms should use Zod validation',
+    severity: 'warning' as const,
+    pattern: /<form[^>]*onSubmit/gi,
+    message: 'Forms should use Zod schema validation.',
+    autoFixable: false,
+    validator: (content: string) => {
+      return content.includes('<form') && 
+             !content.includes('zodResolver') &&
+             !content.includes('z.object');
+    },
+  },
+  {
+    id: 'use-client-directive',
+    name: 'use client directive',
+    description: 'Client components should have "use client" directive',
+    severity: 'error' as const,
+    pattern: /(useState|useEffect|useReducer|useContext|useRef|useCallback|useMemo)\s*\(/g,
+    message: 'Components using hooks must have "use client" directive.',
+    autoFixable: true,
+    validator: (content: string) => {
+      const hasHooks = /(useState|useEffect|useReducer|useContext|useRef|useCallback|useMemo)\s*\(/.test(content);
+      const hasDirective = content.trim().startsWith("'use client'") || content.trim().startsWith('"use client"');
+      return hasHooks && !hasDirective;
+    },
+  },
+  {
+    id: 'key-prop-in-map',
+    name: 'Key prop in map',
+    description: 'Elements in .map() should have key prop',
+    severity: 'error' as const,
+    pattern: /\.map\s*\([^)]*\)\s*=>\s*(?:\(?\s*<[A-Z][^>]*(?!key=)[^>]*>)/g,
+    message: 'Elements in .map() must have a unique key prop.',
+    autoFixable: false,
+  },
+];
+
+export async function checkCommand(options: CheckOptions = {}): Promise<void> {
+  const config = new Config();
+
+  if (!config.isInProject()) {
+    p.log.error('Not in a CodeBakers project.');
+    return;
+  }
+
+  p.intro(chalk.bgCyan.black(' CodeBakers Pattern Check '));
+
+  const spinner = p.spinner();
+  spinner.start('Analyzing code...');
+
+  const result = await runPatternCheck(options.fix || false);
+
+  spinner.stop('Analysis complete');
+
+  // Display results
+  displayResults(result);
+
+  if (result.violations.length > 0 && options.fix) {
+    const fixable = result.violations.filter(v => v.autoFixable);
+    if (fixable.length > 0) {
+      spinner.start(`Auto-fixing ${fixable.length} violations...`);
+      await autoFix(fixable);
+      spinner.stop('Auto-fix complete');
+    }
+  }
+
+  // Exit with error code if there are errors
+  const errors = result.violations.filter(v => v.severity === 'error');
+  if (errors.length > 0) {
+    p.outro(chalk.red(`❌ ${errors.length} errors found. Fix before committing.`));
+    process.exit(1);
+  } else if (result.violations.length > 0) {
+    p.outro(chalk.yellow(`⚠️  ${result.violations.length} warnings. Consider fixing.`));
+  } else {
+    p.outro(chalk.green('✓ All patterns satisfied!'));
+  }
+}
+
+export async function runPatternCheck(autoFix: boolean): Promise<CheckResult> {
+  const cwd = process.cwd();
+  const violations: Violation[] = [];
+
+  // Find all TypeScript/JavaScript files
+  const files = await glob(['src/**/*.{ts,tsx,js,jsx}'], { 
+    cwd,
+    ignore: ['**/node_modules/**', '**/.next/**', '**/dist/**'],
+  });
+
+  for (const file of files) {
+    const filePath = path.join(cwd, file);
+    const content = await fs.readFile(filePath, 'utf-8');
+    const lines = content.split('\n');
+
+    for (const rule of RULES) {
+      // If rule has custom validator, use it
+      if (rule.validator) {
+        // Create a fresh regex for each file
+        const regex = new RegExp(rule.pattern.source, rule.pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+          if (rule.validator(content, match)) {
+            const line = content.substring(0, match.index).split('\n').length;
+            violations.push({
+              file,
+              line,
+              rule: rule.id,
+              message: rule.message,
+              severity: rule.severity,
+              autoFixable: rule.autoFixable,
+            });
+            break; // One violation per rule per file
+          }
+        }
+      } else {
+        // Standard pattern matching
+        const regex = new RegExp(rule.pattern.source, rule.pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+          const line = content.substring(0, match.index).split('\n').length;
+          violations.push({
+            file,
+            line,
+            rule: rule.id,
+            message: rule.message,
+            severity: rule.severity,
+            autoFixable: rule.autoFixable,
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    violations,
+    filesChecked: files.length,
+    passed: violations.length === 0,
+  };
+}
+
+function displayResults(result: CheckResult): void {
+  console.log(chalk.dim(`\nChecked ${result.filesChecked} files\n`));
+
+  if (result.violations.length === 0) {
+    console.log(chalk.green('  ✓ No violations found\n'));
+    return;
+  }
+
+  // Group by file
+  const byFile = new Map<string, Violation[]>();
+  for (const v of result.violations) {
+    if (!byFile.has(v.file)) {
+      byFile.set(v.file, []);
+    }
+    byFile.get(v.file)!.push(v);
+  }
+
+  for (const [file, fileViolations] of byFile) {
+    console.log(chalk.bold(file));
+    
+    for (const v of fileViolations) {
+      const icon = v.severity === 'error' ? chalk.red('✗') : chalk.yellow('⚠');
+      const fixable = v.autoFixable ? chalk.dim(' (auto-fixable)') : '';
+      console.log(`  ${icon} Line ${v.line}: ${v.message}${fixable}`);
+    }
+    
+    console.log('');
+  }
+
+  // Summary
+  const errors = result.violations.filter(v => v.severity === 'error').length;
+  const warnings = result.violations.filter(v => v.severity === 'warning').length;
+  
+  console.log(chalk.bold('Summary:'));
+  if (errors > 0) {
+    console.log(chalk.red(`  ${errors} error(s)`));
+  }
+  if (warnings > 0) {
+    console.log(chalk.yellow(`  ${warnings} warning(s)`));
+  }
+  console.log('');
+}
+
+async function autoFix(violations: Violation[]): Promise<void> {
+  const cwd = process.cwd();
+  
+  // Group by file
+  const byFile = new Map<string, Violation[]>();
+  for (const v of violations) {
+    if (!byFile.has(v.file)) {
+      byFile.set(v.file, []);
+    }
+    byFile.get(v.file)!.push(v);
+  }
+
+  for (const [file, fileViolations] of byFile) {
+    const filePath = path.join(cwd, file);
+    let content = await fs.readFile(filePath, 'utf-8');
+
+    for (const v of fileViolations) {
+      switch (v.rule) {
+        case 'no-console-log':
+          // Remove console.log statements
+          content = content.replace(/console\.log\([^)]*\);?\n?/g, '');
+          break;
+        
+        case 'use-client-directive':
+          // Add "use client" directive at the top
+          if (!content.startsWith("'use client'") && !content.startsWith('"use client"')) {
+            content = "'use client';\n\n" + content;
+          }
+          break;
+      }
+    }
+
+    await fs.writeFile(filePath, content);
+  }
+}
+
+// Export for use in other commands
+export { Violation, CheckResult };