codebakers 1.0.45 → 2.0.1

package/src/utils/config.ts

@@ -0,0 +1,282 @@
+import Conf from 'conf';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import os from 'os';
+import { z } from 'zod';
+
+// Schema for config validation
+const ConfigSchema = z.object({
+  version: z.string().default('1.0.0'),
+  credentials: z.object({
+    github: z.object({
+      token: z.string().optional(),
+      username: z.string().optional(),
+    }).optional(),
+    vercel: z.object({
+      token: z.string().optional(),
+      teamId: z.string().optional(),
+    }).optional(),
+    supabase: z.object({
+      accessToken: z.string().optional(),
+      orgId: z.string().optional(),
+    }).optional(),
+    anthropic: z.object({
+      apiKey: z.string().optional(),
+    }).optional(),
+    openai: z.object({
+      apiKey: z.string().optional(),
+    }).optional(),
+    stripe: z.object({
+      secretKey: z.string().optional(),
+      publishableKey: z.string().optional(),
+      webhookSecret: z.string().optional(),
+    }).optional(),
+    twilio: z.object({
+      accountSid: z.string().optional(),
+      authToken: z.string().optional(),
+      phoneNumber: z.string().optional(),
+    }).optional(),
+    vapi: z.object({
+      apiKey: z.string().optional(),
+    }).optional(),
+    resend: z.object({
+      apiKey: z.string().optional(),
+    }).optional(),
+    elevenLabs: z.object({
+      apiKey: z.string().optional(),
+    }).optional(),
+    microsoft: z.object({
+      clientId: z.string().optional(),
+      clientSecret: z.string().optional(),
+      tenantId: z.string().optional(),
+    }).optional(),
+    google: z.object({
+      clientId: z.string().optional(),
+      clientSecret: z.string().optional(),
+    }).optional(),
+  }).default({}),
+  preferences: z.object({
+    defaultFramework: z.string().optional(),
+    defaultUI: z.string().optional(),
+    defaultPackages: z.array(z.string()).optional(),
+    deployToPreviewFirst: z.boolean().default(true),
+  }).default({}),
+  learning: z.object({
+    enabled: z.boolean().default(true),
+    shortcuts: z.record(z.string()).default({}),
+    preferences: z.record(z.any()).default({}),
+    rejections: z.array(z.string()).default([]),
+    workflows: z.record(z.array(z.string())).default({}),
+  }).default({}),
+  projects: z.array(z.object({
+    name: z.string(),
+    path: z.string(),
+    github: z.string().optional(),
+    vercel: z.string().optional(),
+    supabase: z.string().optional(),
+    createdAt: z.string(),
+  })).default([]),
+  channels: z.object({
+    whatsapp: z.object({
+      enabled: z.boolean().default(false),
+      phoneNumber: z.string().optional(),
+    }).optional(),
+    telegram: z.object({
+      enabled: z.boolean().default(false),
+      botToken: z.string().optional(),
+    }).optional(),
+    discord: z.object({
+      enabled: z.boolean().default(false),
+      botToken: z.string().optional(),
+    }).optional(),
+    slack: z.object({
+      enabled: z.boolean().default(false),
+      botToken: z.string().optional(),
+    }).optional(),
+  }).default({}),
+});
+
+type ConfigType = z.infer<typeof ConfigSchema>;
+
+export class Config {
+  private conf: Conf<ConfigType>;
+  private configDir: string;
+
+  constructor() {
+    this.configDir = path.join(os.homedir(), '.codebakers');
+    
+    // Ensure config directory exists
+    fs.ensureDirSync(this.configDir);
+    fs.ensureDirSync(path.join(this.configDir, 'patterns'));
+    fs.ensureDirSync(path.join(this.configDir, 'templates'));
+    fs.ensureDirSync(path.join(this.configDir, 'learning'));
+
+    this.conf = new Conf<ConfigType>({
+      projectName: 'codebakers',
+      cwd: this.configDir,
+      schema: {
+        version: { type: 'string', default: '1.0.0' },
+        credentials: { type: 'object', default: {} },
+        preferences: { type: 'object', default: {} },
+        learning: { type: 'object', default: { enabled: true, shortcuts: {}, preferences: {}, rejections: [], workflows: {} } },
+        projects: { type: 'array', default: [] },
+        channels: { type: 'object', default: {} },
+      } as any,
+    });
+  }
+
+  // Check if initial setup is complete
+  isConfigured(): boolean {
+    const creds = this.conf.get('credentials') || {};
+    return !!(
+      creds.github?.token &&
+      creds.vercel?.token &&
+      creds.supabase?.accessToken &&
+      creds.anthropic?.apiKey
+    );
+  }
+
+  // Check if current directory is a CodeBakers project
+  isInProject(): boolean {
+    const cwd = process.cwd();
+    const codebakersDir = path.join(cwd, '.codebakers');
+    const claudeFile = path.join(cwd, 'CLAUDE.md');
+    return fs.existsSync(codebakersDir) || fs.existsSync(claudeFile);
+  }
+
+  // Get current project config
+  getProjectConfig(): Record<string, unknown> | null {
+    const cwd = process.cwd();
+    const configPath = path.join(cwd, '.codebakers', 'config.json');
+    if (fs.existsSync(configPath)) {
+      return fs.readJsonSync(configPath);
+    }
+    return null;
+  }
+
+  // Credentials
+  getCredentials(service: string): Record<string, string | undefined> | undefined {
+    const creds = this.conf.get('credentials') || {};
+    return creds[service as keyof typeof creds];
+  }
+
+  setCredentials(service: string, credentials: Record<string, string>): void {
+    const current = this.conf.get('credentials') || {};
+    this.conf.set('credentials', {
+      ...current,
+      [service]: { ...current[service as keyof typeof current], ...credentials },
+    });
+  }
+
+  // Preferences
+  getPreference<T>(key: string): T | undefined {
+    const prefs = this.conf.get('preferences') || {};
+    return prefs[key as keyof typeof prefs] as T;
+  }
+
+  setPreference(key: string, value: unknown): void {
+    const current = this.conf.get('preferences') || {};
+    this.conf.set('preferences', { ...current, [key]: value });
+  }
+
+  // Learning
+  getLearning(): ConfigType['learning'] {
+    return this.conf.get('learning') || { enabled: true, shortcuts: {}, preferences: {}, rejections: [], workflows: {} };
+  }
+
+  addShortcut(shortcut: string, expansion: string): void {
+    const learning = this.getLearning();
+    learning.shortcuts[shortcut] = expansion;
+    this.conf.set('learning', learning);
+  }
+
+  addRejection(item: string): void {
+    const learning = this.getLearning();
+    if (!learning.rejections.includes(item)) {
+      learning.rejections.push(item);
+      this.conf.set('learning', learning);
+    }
+  }
+
+  addWorkflow(name: string, steps: string[]): void {
+    const learning = this.getLearning();
+    learning.workflows[name] = steps;
+    this.conf.set('learning', learning);
+  }
+
+  learnPreference(key: string, value: unknown): void {
+    const learning = this.getLearning();
+    learning.preferences[key] = value;
+    this.conf.set('learning', learning);
+  }
+
+  forgetPreference(key: string): void {
+    const learning = this.getLearning();
+    delete learning.preferences[key];
+    this.conf.set('learning', learning);
+  }
+
+  resetLearning(): void {
+    this.conf.set('learning', { enabled: true, shortcuts: {}, preferences: {}, rejections: [], workflows: {} });
+  }
+
+  // Projects
+  getProjects(): ConfigType['projects'] {
+    return this.conf.get('projects') || [];
+  }
+
+  addProject(project: ConfigType['projects'][0]): void {
+    const projects = this.getProjects();
+    projects.push(project);
+    this.conf.set('projects', projects);
+  }
+
+  // Channels
+  getChannelConfig(channel: string): Record<string, unknown> | undefined {
+    const channels = this.conf.get('channels') || {};
+    return channels[channel as keyof typeof channels];
+  }
+
+  setChannelConfig(channel: string, config: Record<string, unknown>): void {
+    const current = this.conf.get('channels') || {};
+    this.conf.set('channels', { ...current, [channel]: config });
+  }
+
+  // Config directory access
+  getConfigDir(): string {
+    return this.configDir;
+  }
+
+  getPatternsDir(): string {
+    return path.join(this.configDir, 'patterns');
+  }
+
+  getTemplatesDir(): string {
+    return path.join(this.configDir, 'templates');
+  }
+
+  getLearningDir(): string {
+    return path.join(this.configDir, 'learning');
+  }
+
+  // Export/Import
+  exportConfig(): ConfigType {
+    return {
+      version: this.conf.get('version') || '1.0.0',
+      credentials: {}, // Don't export credentials
+      preferences: this.conf.get('preferences') || {},
+      learning: this.getLearning(),
+      projects: this.getProjects(),
+      channels: {}, // Don't export channel tokens
+    };
+  }
+
+  importConfig(config: Partial<ConfigType>): void {
+    if (config.preferences) {
+      this.conf.set('preferences', config.preferences);
+    }
+    if (config.learning) {
+      this.conf.set('learning', config.learning);
+    }
+  }
+}

package/src/utils/updates.ts

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+
+const VERSION = '1.0.0';
+
+export async function checkForUpdates(): Promise<void> {
+  try {
+    const response = await fetch('https://registry.npmjs.org/codebakers/latest', {
+      signal: AbortSignal.timeout(3000),
+    });
+    
+    if (!response.ok) return;
+    
+    const data = await response.json();
+    const latestVersion = data.version;
+    
+    if (latestVersion && latestVersion !== VERSION) {
+      console.log(chalk.yellow(`
+╭────────────────────────────────────────────╮
+│  Update available: ${VERSION} → ${latestVersion.padEnd(10)}        │
+│  Run: npm install -g codebakers            │
+╰────────────────────────────────────────────╯
+`));
+    }
+  } catch {
+    // Silently fail - update check is not critical
+  }
+}

package/tsconfig.json

@@ -1,19 +1,26 @@
 {
   "compilerOptions": {
-    "module": "commonjs",
-    "target": "ES2020",
-    "lib": ["ES2020"],
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
     "outDir": "dist",
     "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
     "sourceMap": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "templates"]
 }

package/.vscodeignore

@@ -1,18 +0,0 @@
-.vscode/**
-.vscode-test/**
-src/**
-node_modules/**
-**/*.ts
-**/*.map
-.gitignore
-tsconfig.json
-esbuild.js
-**/*.d.ts
-**/*.d.ts.map
-preview.html
-nul
-dist/ChatPanelProvider.js
-dist/ChatViewProvider.js
-dist/CodeBakersClient.js
-dist/ProjectContext.js
-dist/nul

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 CodeBakers / BotMakers Software
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.