bytarch-cli 0.1.0

package/src/commands/review.ts

@@ -0,0 +1,242 @@
+import * as path from 'path';
+import { PlanManager } from '../workspace/plan';
+import { EditManager } from '../workspace/edits';
+import { UI } from '../ui/prompts';
+
+export class ReviewCommand {
+  static async execute(options: { plan?: boolean; edits?: boolean }): Promise<void> {
+    const projectRoot = process.cwd();
+    const workspacePath = path.join(projectRoot, '.genie-cli');
+
+    const planManager = new PlanManager(workspacePath);
+    const editManager = new EditManager(workspacePath);
+
+    try {
+      const showPlan = !options.edits;
+      const showEdits = !options.plan;
+
+      if (showPlan) {
+        await this.reviewPlan(planManager);
+      }
+
+      if (showEdits) {
+        await this.reviewEdits(editManager);
+      }
+
+      if (!showPlan && !showEdits) {
+        UI.info('Nothing to review.');
+      }
+
+    } catch (error) {
+      throw new Error(`Failed to review: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  private static async reviewPlan(planManager: PlanManager): Promise<void> {
+    UI.header('📋 Plan Review');
+    
+    const plan = await planManager.loadPlan();
+    
+    if (plan.items.length === 0) {
+      UI.warning('No tasks in the plan.');
+      return;
+    }
+
+    console.log(`Plan: ${plan.title}`);
+    console.log(`Tasks: ${plan.items.length}`);
+    console.log('');
+
+    for (let i = 0; i < plan.items.length; i++) {
+      const item = plan.items[i];
+      const status = this.getStatusIcon(item.status);
+      
+      console.log(`${i + 1}. ${status} ${item.title}`);
+      
+      if (item.description) {
+        console.log(`   ${item.description}`);
+      }
+      
+      if (item.files && item.files.length > 0) {
+        console.log(`   Files: ${item.files.join(', ')}`);
+      }
+      
+      if (item.rationale) {
+        console.log(`   Rationale: ${item.rationale}`);
+      }
+      
+      console.log('');
+    }
+
+    const shouldManage = await UI.confirm({
+      message: 'Manage plan items?',
+      default: false
+    });
+
+    if (shouldManage) {
+      await this.managePlanItems(planManager, plan);
+    }
+  }
+
+  private static async reviewEdits(editManager: EditManager): Promise<void> {
+    UI.header('📝 Edits Review');
+    
+    const edits = await editManager.listEdits();
+    
+    if (edits.length === 0) {
+      UI.warning('No edits found.');
+      return;
+    }
+
+    const pendingEdits = edits.filter(e => e.status === 'pending' || e.status === 'accepted');
+    
+    if (pendingEdits.length === 0) {
+      UI.info('No pending edits to review.');
+      return;
+    }
+
+    console.log(`Pending edits: ${pendingEdits.length}`);
+    console.log('');
+
+    for (let i = 0; i < pendingEdits.length; i++) {
+      const edit = pendingEdits[i];
+      const status = edit.status === 'accepted' ? '✓' : '○';
+      
+      console.log(`${i + 1}. ${status} ${edit.path} (${edit.id})`);
+      console.log(`   ${edit.description}`);
+      
+      if (edit.rationale) {
+        console.log(`   Rationale: ${edit.rationale}`);
+      }
+      
+      console.log('');
+    }
+
+    const shouldManage = await UI.confirm({
+      message: 'Manage edits?',
+      default: true
+    });
+
+    if (shouldManage) {
+      await this.manageEdits(editManager, pendingEdits);
+    }
+  }
+
+  private static async managePlanItems(planManager: PlanManager, plan: any): Promise<void> {
+    const action = await UI.select({
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Update item status', value: 'status' },
+        { name: 'Delete item', value: 'delete' },
+        { name: 'Done', value: 'done' }
+      ]
+    });
+
+    if (action === 'done') return;
+
+    const itemIndex = await UI.select({
+      message: 'Select item:',
+      choices: plan.items.map((item: any, index: number) => ({
+        name: `${item.title}`,
+        value: index
+      }))
+    });
+
+    const item = plan.items[itemIndex];
+
+    if (action === 'status') {
+      const newStatus = await UI.select({
+        message: 'Select new status:',
+        choices: [
+          { name: 'Pending', value: 'pending' },
+          { name: 'In Progress', value: 'in_progress' },
+          { name: 'Completed', value: 'completed' }
+        ],
+        default: item.status
+      });
+
+      await planManager.updatePlanItem(item.id, { status: newStatus });
+      UI.success(`Updated ${item.title} status to ${newStatus}`);
+    } else if (action === 'delete') {
+      const shouldDelete = await UI.confirm({
+        message: `Delete "${item.title}"?`,
+        default: false
+      });
+
+      if (shouldDelete) {
+        await planManager.removePlanItem(item.id);
+        UI.success(`Deleted ${item.title}`);
+      }
+    }
+  }
+
+  private static async manageEdits(editManager: EditManager, edits: any[]): Promise<void> {
+    const action = await UI.select({
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Accept/Reject edit', value: 'status' },
+        { name: 'Preview patch', value: 'preview' },
+        { name: 'Delete edit', value: 'delete' },
+        { name: 'Done', value: 'done' }
+      ]
+    });
+
+    if (action === 'done') return;
+
+    const edit = await UI.select({
+      message: 'Select edit:',
+      choices: edits.map((e: any) => ({
+        name: `${e.path} - ${e.description}`,
+        value: e
+      }))
+    });
+
+    if (action === 'status') {
+      const newStatus = await UI.select({
+        message: 'Select status:',
+        choices: [
+          { name: 'Pending', value: 'pending' },
+          { name: 'Accepted', value: 'accepted' },
+          { name: 'Rejected', value: 'rejected' }
+        ],
+        default: edit.status
+      });
+
+      await editManager.updateEditStatus(edit.id, newStatus);
+      UI.success(`Updated ${edit.path} status to ${newStatus}`);
+    } else if (action === 'preview') {
+      await this.previewEdit(edit);
+    } else if (action === 'delete') {
+      const shouldDelete = await UI.confirm({
+        message: `Delete edit for ${edit.path}?`,
+        default: false
+      });
+
+      if (shouldDelete) {
+        await editManager.deleteEdit(edit.id);
+        UI.success(`Deleted edit for ${edit.path}`);
+      }
+    }
+  }
+
+  private static async previewEdit(edit: any): 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);
+    } catch (error) {
+      UI.error(`Failed to preview patch: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  private static getStatusIcon(status: string): string {
+    switch (status) {
+      case 'completed': return '✓';
+      case 'in_progress': return '⚡';
+      case 'pending': return '○';
+      default: return '?';
+    }
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,101 @@
+import * as path from 'path';
+import { ConfigManager } from '../workspace/config';
+import { PlanManager } from '../workspace/plan';
+import { EditManager } from '../workspace/edits';
+import { UI } from '../ui/prompts';
+
+export class StatusCommand {
+  static async execute(options: { verbose?: boolean }): Promise<void> {
+    const projectRoot = process.cwd();
+    const workspacePath = path.join(projectRoot, '.genie-cli');
+
+    try {
+      const configManager = new ConfigManager(workspacePath);
+      const planManager = new PlanManager(workspacePath);
+      const editManager = new EditManager(workspacePath);
+
+      UI.header('📊 Workspace Status');
+      
+      if (!(await require('fs-extra').pathExists(workspacePath))) {
+        UI.error('No .genie-cli workspace found. Run "bytarch-cli init" to create one.');
+        return;
+      }
+
+      const config = await configManager.loadConfig();
+      const plan = await planManager.loadPlan();
+      const edits = await editManager.listEdits();
+
+      this.displayConfig(config);
+      this.displayPlanStatus(plan, !!options.verbose);
+      this.displayEditStatus(edits, !!options.verbose);
+
+    } catch (error) {
+      throw new Error(`Failed to get status: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  private static displayConfig(config: any): void {
+    UI.info('Configuration:');
+    console.log(`  Provider: ${config.provider}`);
+    console.log(`  Model: ${config.model}`);
+    console.log(`  Endpoint: ${config.endpoint}`);
+    console.log(`  Dry Run: ${config.dryRun ? 'Enabled' : 'Disabled'}`);
+    console.log(`  API Key: ${config.apiKey ? 'Configured' : 'Not configured'}`);
+    console.log('');
+  }
+
+  private static displayPlanStatus(plan: any, verbose: boolean): void {
+    UI.info('Plan Status:');
+    console.log(`  Title: ${plan.title}`);
+    console.log(`  Tasks: ${plan.items.length}`);
+    
+    const completed = plan.items.filter((item: any) => item.status === 'completed').length;
+    const inProgress = plan.items.filter((item: any) => item.status === 'in_progress').length;
+    const pending = plan.items.filter((item: any) => item.status === 'pending').length;
+    
+    console.log(`  ✓ Completed: ${completed}`);
+    console.log(`  ⚡ In Progress: ${inProgress}`);
+    console.log(`  ○ Pending: ${pending}`);
+    
+    if (verbose && plan.items.length > 0) {
+      console.log('');
+      console.log('  Tasks:');
+      plan.items.forEach((item: any, index: number) => {
+        const status = item.status === 'completed' ? '✓' : 
+                      item.status === 'in_progress' ? '⚡' : '○';
+        console.log(`    ${index + 1}. ${status} ${item.title}`);
+      });
+    }
+    
+    console.log('');
+  }
+
+  private static displayEditStatus(edits: any[], verbose: boolean): void {
+    UI.info('Edit Status:');
+    console.log(`  Total Edits: ${edits.length}`);
+    
+    const applied = edits.filter(edit => edit.status === 'applied').length;
+    const accepted = edits.filter(edit => edit.status === 'accepted').length;
+    const pending = edits.filter(edit => edit.status === 'pending').length;
+    const rejected = edits.filter(edit => edit.status === 'rejected').length;
+    
+    console.log(`  ✓ Applied: ${applied}`);
+    console.log(`  ✓ Accepted: ${accepted}`);
+    console.log(`  ○ Pending: ${pending}`);
+    console.log(`  ✗ Rejected: ${rejected}`);
+    
+    if (verbose && edits.length > 0) {
+      console.log('');
+      console.log('  Recent Edits:');
+      const recentEdits = edits.slice(0, 5);
+      recentEdits.forEach((edit, index) => {
+        const status = edit.status === 'applied' ? '✓' : 
+                      edit.status === 'accepted' ? '✓' :
+                      edit.status === 'pending' ? '○' : '✗';
+        console.log(`    ${index + 1}. ${status} ${edit.path} - ${edit.description}`);
+      });
+    }
+    
+    console.log('');
+  }
+}

package/src/fs/patcher.ts

@@ -0,0 +1,188 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as diff from 'diff';
+import { FileEdit } from '../workspace/edits';
+
+export interface PatchResult {
+  success: boolean;
+  error?: string;
+  appliedChanges?: number;
+}
+
+export class Patcher {
+  private projectRoot: string;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+  }
+
+  async previewPatch(edit: FileEdit): Promise<string> {
+    const filePath = this.resolvePath(edit.path);
+    
+    try {
+      let originalContent = '';
+      if (await fs.pathExists(filePath)) {
+        originalContent = await fs.readFile(filePath, 'utf8');
+      }
+
+      return this.formatPatchPreview(edit.patch, filePath, originalContent);
+    } catch (error) {
+      throw new Error(`Failed to preview patch for ${edit.path}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  async applyPatch(edit: FileEdit): Promise<PatchResult> {
+    const filePath = this.resolvePath(edit.path);
+    
+    try {
+      await this.ensureDirectoryExists(filePath);
+      
+      let originalContent = '';
+      if (await fs.pathExists(filePath)) {
+        originalContent = await fs.readFile(filePath, 'utf8');
+      }
+
+      const result = this.applyUnifiedDiff(originalContent, edit.patch);
+      
+      if (result.success) {
+        await fs.writeFile(filePath, result.content!, 'utf8');
+        return {
+          success: true,
+          appliedChanges: result.changes
+        };
+      } else {
+        return {
+          success: false,
+          error: result.error
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  private formatPatchPreview(patchString: string, filePath: string, originalContent: string): string {
+    const lines = patchString.split('\n');
+    let preview = `\n📁 File: ${filePath}\n`;
+    preview += `${'='.repeat(60)}\n\n`;
+    
+    for (const line of lines) {
+      if (line.startsWith('---') || line.startsWith('+++')) {
+        preview += `\x1b[36m${line}\x1b[0m\n`;
+      } else if (line.startsWith('@@')) {
+        preview += `\x1b[33m${line}\x1b[0m\n`;
+      } else if (line.startsWith('+')) {
+        preview += `\x1b[32m${line}\x1b[0m\n`;
+      } else if (line.startsWith('-')) {
+        preview += `\x1b[31m${line}\x1b[0m\n`;
+      } else if (line.startsWith(' ')) {
+        preview += `${line}\n`;
+      } else {
+        preview += `${line}\n`;
+      }
+    }
+    
+    return preview;
+  }
+
+  private applyUnifiedDiff(originalContent: string, patchString: string): { success: boolean; content?: string; changes?: number; error?: string } {
+    try {
+      const lines = patchString.split('\n');
+      let isHeader = true;
+      let hunkStart = -1;
+      let hunkLines = 0;
+      let contextLines = 0;
+      let deletions = 0;
+      let additions = 0;
+      
+      let result = originalContent.split('\n');
+      let resultIndex = 0;
+      
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        
+        if (isHeader) {
+          if (line.startsWith('---') || line.startsWith('+++')) {
+            continue;
+          } else if (line.startsWith('@@')) {
+            isHeader = false;
+            const match = line.match(/@@ -(\\d+)(?:,(\\d+))? \\+(\\d+)(?:,(\\d+))? @@/);
+            if (match) {
+              hunkStart = parseInt(match[1]) - 1;
+              hunkLines = parseInt(match[4] || match[2] || '1');
+            }
+            continue;
+          } else {
+            continue;
+          }
+        }
+        
+        if (line.startsWith(' ')) {
+          contextLines++;
+          resultIndex++;
+        } else if (line.startsWith('-')) {
+          deletions++;
+          if (resultIndex < result.length) {
+            result.splice(resultIndex, 1);
+          }
+        } else if (line.startsWith('+')) {
+          additions++;
+          result.splice(resultIndex, 0, line.substring(1));
+          resultIndex++;
+        }
+      }
+      
+      return {
+        success: true,
+        content: result.join('\n'),
+        changes: additions + deletions
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown patch application error'
+      };
+    }
+  }
+
+  private resolvePath(relativePath: string): string {
+    const sanitized = relativePath.replace(/\.\./g, '').replace(/^\//, '');
+    return path.resolve(this.projectRoot, sanitized);
+  }
+
+  private async ensureDirectoryExists(filePath: string): Promise<void> {
+    const dir = path.dirname(filePath);
+    await fs.ensureDir(dir);
+  }
+
+  async createBackup(filePath: string): Promise<string | null> {
+    try {
+      if (await fs.pathExists(filePath)) {
+        const backupPath = `${filePath}.backup.${Date.now()}`;
+        await fs.copy(filePath, backupPath);
+        return backupPath;
+      }
+      return null;
+    } catch (error) {
+      console.warn(`Failed to create backup for ${filePath}:`, error);
+      return null;
+    }
+  }
+
+  async restoreFromBackup(filePath: string, backupPath: string): Promise<boolean> {
+    try {
+      if (await fs.pathExists(backupPath)) {
+        await fs.copy(backupPath, filePath);
+        await fs.remove(backupPath);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.warn(`Failed to restore from backup ${backupPath}:`, error);
+      return false;
+    }
+  }
+}

package/src/fs/safe-readwrite.ts

@@ -0,0 +1,141 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+export class SafeFileSystem {
+  private projectRoot: string;
+  private allowedPaths: Set<string>;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = path.resolve(projectRoot);
+    this.allowedPaths = new Set();
+  }
+
+  setAllowedPaths(paths: string[]): void {
+    this.allowedPaths = new Set(paths.map(p => path.resolve(this.projectRoot, p)));
+  }
+
+  async safeReadFile(filePath: string): Promise<string> {
+    const resolvedPath = this.resolvePath(filePath);
+    this.validatePath(resolvedPath);
+    
+    if (!(await fs.pathExists(resolvedPath))) {
+      throw new Error(`File does not exist: ${filePath}`);
+    }
+    
+    const stats = await fs.stat(resolvedPath);
+    if (!stats.isFile()) {
+      throw new Error(`Path is not a file: ${filePath}`);
+    }
+    
+    return await fs.readFile(resolvedPath, 'utf8');
+  }
+
+  async safeWriteFile(filePath: string, content: string): Promise<void> {
+    const resolvedPath = this.resolvePath(filePath);
+    this.validatePath(resolvedPath);
+    
+    await fs.ensureDir(path.dirname(resolvedPath));
+    await fs.writeFile(resolvedPath, content, 'utf8');
+  }
+
+  async safeReadDir(dirPath: string): Promise<string[]> {
+    const resolvedPath = this.resolvePath(dirPath);
+    this.validatePath(resolvedPath);
+    
+    if (!(await fs.pathExists(resolvedPath))) {
+      throw new Error(`Directory does not exist: ${dirPath}`);
+    }
+    
+    const stats = await fs.stat(resolvedPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${dirPath}`);
+    }
+    
+    return await fs.readdir(resolvedPath);
+  }
+
+  async safeExists(filePath: string): Promise<boolean> {
+    const resolvedPath = this.resolvePath(filePath);
+    this.validatePath(resolvedPath);
+    return await fs.pathExists(resolvedPath);
+  }
+
+  async safeStat(filePath: string): Promise<fs.Stats | null> {
+    const resolvedPath = this.resolvePath(filePath);
+    this.validatePath(resolvedPath);
+    
+    try {
+      return await fs.stat(resolvedPath);
+    } catch {
+      return null;
+    }
+  }
+
+  async safeCopy(src: string, dest: string): Promise<void> {
+    const srcPath = this.resolvePath(src);
+    const destPath = this.resolvePath(dest);
+    
+    this.validatePath(srcPath);
+    this.validatePath(destPath);
+    
+    await fs.ensureDir(path.dirname(destPath));
+    await fs.copy(srcPath, destPath);
+  }
+
+  async safeMove(src: string, dest: string): Promise<void> {
+    const srcPath = this.resolvePath(src);
+    const destPath = this.resolvePath(dest);
+    
+    this.validatePath(srcPath);
+    this.validatePath(destPath);
+    
+    await fs.ensureDir(path.dirname(destPath));
+    await fs.move(srcPath, destPath);
+  }
+
+  async safeRemove(target: string): Promise<void> {
+    const resolvedPath = this.resolvePath(target);
+    this.validatePath(resolvedPath);
+    await fs.remove(resolvedPath);
+  }
+
+  getFileExtension(filePath: string): string {
+    return path.extname(filePath).toLowerCase();
+  }
+
+  getRelativePath(filePath: string): string {
+    const resolvedPath = this.resolvePath(filePath);
+    return path.relative(this.projectRoot, resolvedPath);
+  }
+
+  private resolvePath(filePath: string): string {
+    const normalized = path.normalize(filePath);
+    
+    if (path.isAbsolute(normalized)) {
+      return normalized;
+    }
+    
+    return path.resolve(this.projectRoot, normalized);
+  }
+
+  private validatePath(resolvedPath: string): void {
+    if (!resolvedPath.startsWith(this.projectRoot)) {
+      throw new Error(`Access denied: Path ${resolvedPath} is outside project root ${this.projectRoot}`);
+    }
+    
+    if (this.allowedPaths.size > 0) {
+      const isAllowed = Array.from(this.allowedPaths).some(allowed => 
+        resolvedPath.startsWith(allowed) || resolvedPath === allowed
+      );
+      
+      if (!isAllowed) {
+        throw new Error(`Access denied: Path ${resolvedPath} is not in allowed paths`);
+      }
+    }
+    
+    const relativePath = path.relative(this.projectRoot, resolvedPath);
+    if (relativePath.includes('..')) {
+      throw new Error(`Access denied: Path traversal detected in ${relativePath}`);
+    }
+  }
+}