bytarch-cli 0.1.0

package/src/commands/config.ts

@@ -0,0 +1,194 @@
+import * as path from 'path';
+import { ConfigManager } from '../workspace/config';
+import { UI } from '../ui/prompts';
+
+export class ConfigCommand {
+  static async execute(options: { 
+    set?: string; 
+    get?: string; 
+    list?: boolean; 
+    setApiKey?: string;
+  }): Promise<void> {
+    const projectRoot = process.cwd();
+    const workspacePath = path.join(projectRoot, '.genie-cli');
+
+    try {
+      if (!(await require('fs-extra').pathExists(workspacePath))) {
+        UI.error('No .genie-cli workspace found. Run "bytarch-cli init" to create one.');
+        return;
+      }
+
+      const configManager = new ConfigManager(workspacePath);
+
+      if (options.setApiKey) {
+        await this.setApiKey(configManager, options.setApiKey);
+        return;
+      }
+
+      if (options.set) {
+        await this.setConfig(configManager, options.set);
+        return;
+      }
+
+      if (options.get) {
+        await this.getConfig(configManager, options.get);
+        return;
+      }
+
+      if (options.list) {
+        await this.listConfig(configManager);
+        return;
+      }
+
+      await this.interactiveConfig(configManager);
+
+    } catch (error) {
+      throw new Error(`Config operation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  private static async setApiKey(configManager: ConfigManager, apiKey: string): Promise<void> {
+    await configManager.updateConfig({ apiKey });
+    UI.success('API key updated successfully.');
+  }
+
+  private static async setConfig(configManager: ConfigManager, setOption: string): Promise<void> {
+    const [key, value] = setOption.split('=');
+    
+    if (!key || !value) {
+      UI.error('Invalid format. Use: --set key=value');
+      return;
+    }
+
+    const config = await configManager.loadConfig();
+    
+    if (!(key in config)) {
+      UI.error(`Unknown configuration key: ${key}`);
+      UI.info('Available keys: provider, endpoint, model, dryRun');
+      return;
+    }
+
+    let parsedValue: any = value;
+    
+    if (key === 'dryRun') {
+      parsedValue = value.toLowerCase() === 'true';
+    }
+
+    const updates: any = {};
+    updates[key] = parsedValue;
+    
+    await configManager.updateConfig(updates);
+    UI.success(`Updated ${key} to ${value}`);
+  }
+
+  private static async getConfig(configManager: ConfigManager, key: string): Promise<void> {
+    const config = await configManager.loadConfig();
+    
+    if (!(key in config)) {
+      UI.error(`Unknown configuration key: ${key}`);
+      UI.info('Available keys: provider, endpoint, model, dryRun, apiKey');
+      return;
+    }
+
+    let value = (config as any)[key];
+    
+    if (key === 'apiKey') {
+      value = value ? '***configured***' : 'not configured';
+    }
+
+    console.log(`${key}: ${value}`);
+  }
+
+  private static async listConfig(configManager: ConfigManager): Promise<void> {
+    const config = await configManager.loadConfig();
+    
+    UI.header('Configuration:');
+    
+    Object.entries(config).forEach(([key, value]) => {
+      let displayValue = value;
+      
+      if (key === 'apiKey') {
+        displayValue = value ? '***configured***' : 'not configured';
+      }
+      
+      console.log(`  ${key}: ${displayValue}`);
+    });
+    
+    console.log('');
+    UI.info('Environment variables:');
+    console.log(`  BYTARCH_API_KEY: ${process.env.BYTARCH_API_KEY ? 'set' : 'not set'}`);
+    console.log(`  BYTARCH_ENDPOINT: ${process.env.BYTARCH_ENDPOINT || 'not set'}`);
+    console.log(`  BYTARCH_MODEL: ${process.env.BYTARCH_MODEL || 'not set'}`);
+  }
+
+  private static async interactiveConfig(configManager: ConfigManager): Promise<void> {
+    UI.header('Interactive Configuration');
+    
+    const action = await UI.select({
+      message: 'What would you like to configure?',
+      choices: [
+        { name: 'Set API Key', value: 'apiKey' },
+        { name: 'Set Model', value: 'model' },
+        { name: 'Set Endpoint', value: 'endpoint' },
+        { name: 'Toggle Dry Run', value: 'dryRun' },
+        { name: 'Show Current Config', value: 'show' },
+        { name: 'Done', value: 'done' }
+      ]
+    });
+
+    if (action === 'done') return;
+
+    const config = await configManager.loadConfig();
+
+    switch (action) {
+      case 'apiKey':
+        const apiKey = await UI.input({
+          message: 'Enter BYTARCH API key:',
+          validate: (input) => input.length > 0 || 'API key cannot be empty'
+        });
+        await configManager.updateConfig({ apiKey });
+        UI.success('API key updated.');
+        break;
+
+      case 'model':
+        const model = await UI.input({
+          message: 'Enter model name:',
+          default: config.model
+        });
+        await configManager.updateConfig({ model });
+        UI.success(`Model updated to: ${model}`);
+        break;
+
+      case 'endpoint':
+        const endpoint = await UI.input({
+          message: 'Enter API endpoint:',
+          default: config.endpoint
+        });
+        await configManager.updateConfig({ endpoint });
+        UI.success(`Endpoint updated to: ${endpoint}`);
+        break;
+
+      case 'dryRun':
+        const dryRun = await UI.confirm({
+          message: `Dry run is currently ${config.dryRun ? 'enabled' : 'disabled'}. Toggle?`,
+          default: true
+        });
+        await configManager.updateConfig({ dryRun: !config.dryRun });
+        UI.success(`Dry run ${!config.dryRun ? 'enabled' : 'disabled'}.`);
+        break;
+
+      case 'show':
+        await this.listConfig(configManager);
+        break;
+    }
+
+    const shouldContinue = await UI.confirm({
+      message: 'Configure more settings?',
+      default: false
+    });
+
+    if (shouldContinue) {
+      await this.interactiveConfig(configManager);
+    }
+  }
+}

package/src/commands/edit.ts

@@ -0,0 +1,133 @@
+import * as path from 'path';
+import { ConfigManager } from '../workspace/config';
+import { EditManager, FileEdit } from '../workspace/edits';
+import { BytarchProvider } from '../provider/bytarch';
+import { EDIT_PROMPT } from '../provider/prompts';
+import { extractJsonFromResponse, isValidEditResponse } from '../provider/evaluation';
+import { UI } from '../ui/prompts';
+
+export class EditCommand {
+  static async execute(filePath: string, request: string = '', options: { description?: string }): Promise<void> {
+    const projectRoot = process.cwd();
+    const workspacePath = path.join(projectRoot, '.genie-cli');
+
+    const configManager = new ConfigManager(workspacePath);
+    const editManager = new EditManager(workspacePath);
+
+    try {
+      const config = await configManager.loadConfig();
+      const apiKey = configManager.getApiKey(config);
+
+      if (!request) {
+        request = await UI.input({
+          message: 'Describe the changes you want to make:',
+          validate: (input) => input.length > 0 || 'Please describe the changes'
+        });
+      }
+
+      UI.header(`Generating edit for ${filePath}...`);
+
+      const provider = new BytarchProvider(config.endpoint, config.model, apiKey);
+      
+      let fileContent = '';
+      try {
+        const fs = require('fs-extra');
+        const resolvedPath = path.resolve(projectRoot, filePath);
+        if (await fs.pathExists(resolvedPath)) {
+          fileContent = await fs.readFile(resolvedPath, 'utf8');
+        }
+      } catch (error) {
+        UI.warning(`Could not read file ${filePath}, will create new file`);
+      }
+
+      const messages = [
+        {
+          role: 'system' as const,
+          content: EDIT_PROMPT
+        },
+        {
+          role: 'user' as const,
+          content: `File: ${filePath}\\nRequest: ${request}\\n${fileContent ? `Current content:\\n\\n${fileContent}` : 'File does not exist, create new file.'}\\n\\nGenerate a unified diff patch for these changes.`
+        }
+      ];
+
+      const response = await provider.chat(messages);
+      const editData = extractJsonFromResponse(response);
+
+      if (!isValidEditResponse(editData)) {
+        throw new Error('Invalid edit response from AI');
+      }
+
+      const edit: FileEdit = {
+        id: editManager.generateEditId(),
+        path: filePath,
+        description: options.description || editData.description,
+        rationale: editData.rationale,
+        patch: editData.patch,
+        status: 'pending',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      };
+
+      await editManager.saveEdit(edit);
+
+      UI.success('Edit generated successfully!');
+      this.displayEdit(edit);
+
+      const shouldReview = await UI.confirm({
+        message: 'Would you like to review this edit now?',
+        default: true
+      });
+
+      if (shouldReview) {
+        await this.showPatchPreview(edit);
+      }
+
+    } catch (error) {
+      throw new Error(`Failed to generate edit: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  private static displayEdit(edit: FileEdit): void {
+    UI.divider();
+    UI.header(`📝 Edit: ${edit.path}`);
+    console.log(edit.description);
+    console.log('');
+    
+    if (edit.rationale) {
+      UI.info('Rationale:');
+      console.log(edit.rationale);
+      console.log('');
+    }
+
+    console.log(`Status: ${edit.status}`);
+    console.log(`ID: ${edit.id}`);
+    console.log('');
+  }
+
+  private static async showPatchPreview(edit: FileEdit): Promise<void> {
+    const { Patcher } = await import('../fs/patcher');
+    const projectRoot = process.cwd();
+    const patcher = new Patcher(projectRoot);
+
+    try {
+      const preview = await patcher.previewPatch(edit);
+      console.log(preview);
+      
+      const shouldAccept = await UI.confirm({
+        message: 'Accept this edit?',
+        default: false
+      });
+
+      if (shouldAccept) {
+        const editManager = new EditManager(path.join(projectRoot, '.genie-cli'));
+        await editManager.updateEditStatus(edit.id, 'accepted');
+        UI.success('Edit accepted. Use "bytarch-cli apply" to apply changes.');
+      } else {
+        UI.info('Edit remains pending for review.');
+      }
+    } catch (error) {
+      UI.error(`Failed to preview patch: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,62 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import chalk from 'chalk';
+import { UI } from '../ui/prompts';
+
+export class InitCommand {
+  static async execute(options: { force?: boolean }): Promise<void> {
+    const projectRoot = process.cwd();
+    const workspacePath = path.join(projectRoot, '.genie-cli');
+
+    if (await fs.pathExists(workspacePath)) {
+      if (!options.force) {
+        const shouldContinue = await UI.confirm({
+          message: 'Workspace already exists. Do you want to reinitialize?',
+          default: false
+        });
+
+        if (!shouldContinue) {
+          UI.info('Initialization cancelled.');
+          return;
+        }
+      }
+
+      await fs.remove(workspacePath);
+      UI.warning('Removed existing workspace.');
+    }
+
+    await fs.ensureDir(workspacePath);
+    await fs.ensureDir(path.join(workspacePath, 'edits'));
+    await fs.ensureDir(path.join(workspacePath, 'history'));
+
+    const defaultConfig = {
+      provider: 'bytarch',
+      endpoint: 'https://api.bytarch.dpdns.org/openai/v1/chat/completions',
+      model: 'gpt-5-nano',
+      apiKey: '',
+      dryRun: true
+    };
+
+    await fs.writeJson(path.join(workspacePath, 'config.json'), defaultConfig, { spaces: 2 });
+
+    const defaultPlan = {
+      id: 'default',
+      title: 'Project Plan',
+      description: 'Generated project plan',
+      items: [],
+      rationale: '',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+
+    await fs.writeJson(path.join(workspacePath, 'plan.json'), defaultPlan, { spaces: 2 });
+
+    UI.success(`Initialized .genie-cli workspace in ${projectRoot}`);
+    UI.info('Next steps:');
+    UI.list([
+      'Set your API key: bytarch-cli config --set-api-key YOUR_API_KEY',
+      'Generate a plan: bytarch-cli plan "your project description"',
+      'Propose edits: bytarch-cli edit path/to/file.js "your request"'
+    ]);
+  }
+}

package/src/commands/plan.ts

@@ -0,0 +1,163 @@
+import * as path from 'path';
+import { ConfigManager } from '../workspace/config';
+import { PlanManager, Plan } from '../workspace/plan';
+import { BytarchProvider } from '../provider/bytarch';
+import { PLAN_PROMPT } from '../provider/prompts';
+import { extractJsonFromResponse, isValidPlanResponse } from '../provider/evaluation';
+import { UI } from '../ui/prompts';
+
+export class PlanCommand {
+  static async execute(description: string = '', options: { context?: string; analyze?: boolean }): Promise<void> {
+    const projectRoot = process.cwd();
+    const workspacePath = path.join(projectRoot, '.genie-cli');
+
+    const configManager = new ConfigManager(workspacePath);
+    const planManager = new PlanManager(workspacePath);
+
+    try {
+      const config = await configManager.loadConfig();
+      const apiKey = configManager.getApiKey(config);
+
+      if (!description) {
+        description = await UI.input({
+          message: 'Describe your project or goal:',
+          validate: (input) => input.length > 0 || 'Please provide a description'
+        });
+      }
+
+      UI.header('Generating project plan...');
+
+      const provider = new BytarchProvider(config.endpoint, config.model, apiKey);
+      
+      let contextInfo = '';
+      if (options.analyze) {
+        contextInfo = await this.analyzeProject(projectRoot);
+      }
+
+      if (options.context) {
+        try {
+          const contextContent = await require('fs-extra').readFile(options.context, 'utf8');
+          contextInfo += `\\n\\nAdditional context from ${options.context}:\\n${contextContent}`;
+        } catch (error) {
+          UI.warning(`Could not read context file: ${options.context}`);
+        }
+      }
+
+      const messages = [
+        {
+          role: 'system' as const,
+          content: PLAN_PROMPT
+        },
+        {
+          role: 'user' as const,
+          content: `Project description: ${description}\\n${contextInfo ? `Context:\\n${contextInfo}` : ''}\\n\\nGenerate a comprehensive plan for this project.`
+        }
+      ];
+
+      const response = await provider.chat(messages);
+      const planData = extractJsonFromResponse(response);
+
+      if (!isValidPlanResponse(planData)) {
+        throw new Error('Invalid plan response from AI');
+      }
+
+      const plan: Plan = {
+        ...planData,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      };
+
+      await planManager.savePlan(plan);
+
+      UI.success('Project plan generated successfully!');
+      this.displayPlan(plan);
+
+    } catch (error) {
+      throw new Error(`Failed to generate plan: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  private static async analyzeProject(projectRoot: string): Promise<string> {
+    const fs = require('fs-extra');
+    const path = require('path');
+
+    const analysis: string[] = [];
+    
+    try {
+      const packageJsonPath = path.join(projectRoot, 'package.json');
+      if (await fs.pathExists(packageJsonPath)) {
+        const packageJson = await fs.readJson(packageJsonPath);
+        analysis.push(`Project: ${packageJson.name || 'Unknown'}`);
+        analysis.push(`Scripts: ${Object.keys(packageJson.scripts || {}).join(', ')}`);
+        analysis.push(`Dependencies: ${Object.keys(packageJson.dependencies || {}).length}`);
+      }
+
+      const srcPath = path.join(projectRoot, 'src');
+      if (await fs.pathExists(srcPath)) {
+        const files = await this.getFilesRecursive(srcPath);
+        const jsFiles = files.filter((f: string) => f.endsWith('.js') || f.endsWith('.ts'));
+        analysis.push(`Source files: ${jsFiles.length} (${jsFiles.map((f: string) => path.extname(f)).join(', ')})`);
+      }
+
+    } catch (error) {
+      UI.warning('Could not analyze project structure');
+    }
+
+    return analysis.join('\\n');
+  }
+
+  private static async getFilesRecursive(dir: string): Promise<string[]> {
+    const fs = require('fs-extra');
+    const path = require('path');
+    let files: string[] = [];
+
+    const items = await fs.readdir(dir);
+    for (const item of items) {
+      const fullPath = path.join(dir, item);
+      const stat = await fs.stat(fullPath);
+      
+      if (stat.isDirectory()) {
+        files = files.concat(await this.getFilesRecursive(fullPath));
+      } else {
+        files.push(fullPath);
+      }
+    }
+    
+    return files;
+  }
+
+  private static displayPlan(plan: Plan): void {
+    UI.divider();
+    UI.header(`📋 ${plan.title}`);
+    console.log(plan.description);
+    console.log('');
+    
+    if (plan.rationale) {
+      UI.info('Rationale:');
+      console.log(plan.rationale);
+      console.log('');
+    }
+
+    if (plan.items.length === 0) {
+      UI.warning('No tasks in the plan.');
+      return;
+    }
+
+    console.log('Tasks:');
+    plan.items.forEach((item, index) => {
+      const status = item.status === 'completed' ? '✓' : 
+                    item.status === 'in_progress' ? '⚡' : '○';
+      console.log(`${index + 1}. ${status} ${item.title}`);
+      
+      if (item.description) {
+        console.log(`   ${item.description}`);
+      }
+      
+      if (item.files && item.files.length > 0) {
+        console.log(`   Files: ${item.files.join(', ')}`);
+      }
+      
+      console.log('');
+    });
+  }
+}