bytarch-cli 0.1.0

package/src/index.ts

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import * as path from 'path';
+import chalk from 'chalk';
+
+import { InitCommand } from './commands/init';
+import { PlanCommand } from './commands/plan';
+import { EditCommand } from './commands/edit';
+import { ReviewCommand } from './commands/review';
+import { ApplyCommand } from './commands/apply';
+import { StatusCommand } from './commands/status';
+import { ConfigCommand } from './commands/config';
+
+const program = new Command();
+
+program
+  .name('bytarch-cli')
+  .description('AI-powered CLI for project planning and code editing using BYTARCH')
+  .version('0.1.0');
+
+program
+  .command('init')
+  .description('Initialize a .genie-cli workspace')
+  .option('-f, --force', 'Force initialization even if workspace already exists')
+  .action(async (options) => {
+    try {
+      await InitCommand.execute(options);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+program
+  .command('plan')
+  .description('Generate a project plan using AI')
+  .argument('[description]', 'Project description or goal')
+  .option('-c, --context <file>', 'Provide additional context from a file')
+  .option('-a, --analyze', 'Analyze current repository before planning')
+  .action(async (description, options) => {
+    try {
+      await PlanCommand.execute(description, options);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+program
+  .command('edit')
+  .description('Propose edits to a file using AI')
+  .argument('<path>', 'File path to edit')
+  .argument('[request]', 'Description of changes to make')
+  .option('-d, --description <desc>', 'Description of the changes')
+  .action(async (filePath, request, options) => {
+    try {
+      await EditCommand.execute(filePath, request, options);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+program
+  .command('review')
+  .description('Review and manage pending edits and plan')
+  .option('-p, --plan', 'Show only plan items')
+  .option('-e, --edits', 'Show only pending edits')
+  .action(async (options) => {
+    try {
+      await ReviewCommand.execute(options);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+program
+  .command('apply')
+  .description('Apply accepted edits (dry-run by default)')
+  .option('-f, --force', 'Apply edits without confirmation (use with caution)')
+  .option('-d, --dry-run', 'Show what would be applied without making changes')
+  .option('-i, --ids <ids>', 'Apply only specific edit IDs (comma-separated)')
+  .action(async (options) => {
+    try {
+      await ApplyCommand.execute(options);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('Show workspace and plan status')
+  .option('-v, --verbose', 'Show detailed information')
+  .action(async (options) => {
+    try {
+      await StatusCommand.execute(options);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+program
+  .command('config')
+  .description('Manage configuration')
+  .option('-s, --set <key=value>', 'Set configuration value')
+  .option('-g, --get <key>', 'Get configuration value')
+  .option('-l, --list', 'List all configuration')
+  .option('--set-api-key <key>', 'Set BYTARCH API key')
+  .action(async (options) => {
+    try {
+      await ConfigCommand.execute(options);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/provider/bytarch.ts

@@ -0,0 +1,75 @@
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface BytarchResponse {
+  choices: Array<{
+    message: {
+      role: string;
+      content: string;
+    };
+  }>;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export class BytarchProvider {
+  private endpoint: string;
+  private model: string;
+  private apiKey: string;
+
+  constructor(endpoint: string, model: string, apiKey: string) {
+    this.endpoint = endpoint;
+    this.model = model;
+    this.apiKey = apiKey;
+  }
+
+  async chat(messages: ChatMessage[]): Promise<string> {
+    if (!this.apiKey) {
+      throw new Error('BYTARCH API key is required. Set BYTARCH_API_KEY environment variable or configure in .genie-cli/config.json');
+    }
+
+    try {
+      const response = await fetch(this.endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages,
+          stream: false
+        })
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`BYTARCH API request failed (${response.status}): ${errorText}`);
+      }
+
+      const data = (await response.json()) as BytarchResponse;
+      
+      if (!data.choices || data.choices.length === 0) {
+        throw new Error('No response from BYTARCH API');
+      }
+
+      return data.choices[0].message.content;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`BYTARCH provider error: ${error.message}`);
+      }
+      throw new Error('Unknown BYTARCH provider error');
+    }
+  }
+
+  updateConfig(endpoint: string, model: string, apiKey: string): void {
+    this.endpoint = endpoint;
+    this.model = model;
+    this.apiKey = apiKey;
+  }
+}

package/src/provider/evaluation.ts

@@ -0,0 +1,39 @@
+export function isValidPlanResponse(data: any): boolean {
+  if (!data || typeof data !== 'object') return false;
+  
+  return (
+    typeof data.id === 'string' &&
+    typeof data.title === 'string' &&
+    typeof data.description === 'string' &&
+    Array.isArray(data.items) &&
+    typeof data.rationale === 'string'
+  );
+}
+
+export function isValidEditResponse(data: any): boolean {
+  if (!data || typeof data !== 'object') return false;
+  
+  return (
+    typeof data.id === 'string' &&
+    typeof data.path === 'string' &&
+    typeof data.description === 'string' &&
+    typeof data.rationale === 'string' &&
+    typeof data.patch === 'string'
+  );
+}
+
+export function extractJsonFromResponse(content: string): any {
+  try {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error('No JSON found in response');
+    }
+    return JSON.parse(jsonMatch[0]);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON from AI response: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+export function sanitizePath(path: string): string {
+  return path.replace(/\./g, '').replace(/^\//, '');
+}

package/src/provider/prompts.ts

@@ -0,0 +1,59 @@
+export const PLAN_PROMPT = `You are an expert software architect and developer. Given a project description or repository context, generate an actionable plan for implementing the project.
+
+Your response should be a JSON object with the following structure:
+{
+  "id": "plan-id",
+  "title": "Project title",
+  "description": "Brief description of the project",
+  "items": [
+    {
+      "id": "task-id",
+      "title": "Task title",
+      "description": "Detailed description of what needs to be done",
+      "status": "pending",
+      "rationale": "Why this task is necessary",
+      "files": ["file1.js", "file2.ts"] // files that will be created/modified
+    }
+  ],
+  "rationale": "Overall rationale for the plan"
+}
+
+Focus on:
+1. Breaking down the project into manageable tasks
+2. Identifying files that need to be created or modified
+3. Providing clear rationale for each task
+4. Using realistic estimates for task complexity
+
+Be specific about file paths and implementations needed.`;
+
+export const EDIT_PROMPT = `You are an expert software developer. Given a file path and a request for changes, generate a unified diff patch for the requested edits.
+
+Your response should be a JSON object with the following structure:
+{
+  "id": "patch-id",
+  "path": "path/to/file.js",
+  "description": "Brief description of the changes",
+  "rationale": "Why these changes are necessary",
+  "patch": "--- a/path/to/file.js\\n+++ b/path/to/file.js\\n@@ -1,3 +1,5 @@\\n existing content\\n+new content\\n-more content"
+}
+
+Guidelines:
+1. Generate valid unified diff format
+2. Be precise about line numbers
+3. Include context lines in the diff
+4. Explain the reasoning for changes
+5. If the file doesn't exist, create a new file patch
+
+Always include the full unified diff in the "patch" field.`;
+
+export const ANALYSIS_PROMPT = `You are an expert code reviewer. Analyze the current repository structure and provide insights for project planning.
+
+Focus on:
+1. Current project structure and architecture
+2. Existing technologies and frameworks used
+3. Areas that need improvement or new features
+4. Dependencies and package management
+5. Testing setup and coverage
+6. Documentation status
+
+Provide a concise summary that would help in generating an effective project plan.`;

package/src/ui/prompts.ts

@@ -0,0 +1,163 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+export interface ConfirmOptions {
+  message: string;
+  default?: boolean;
+}
+
+export interface SelectOptions {
+  message: string;
+  choices: Array<{ name: string; value: any; short?: string }>;
+  default?: any;
+}
+
+export interface InputOptions {
+  message: string;
+  default?: string;
+  validate?: (input: string) => boolean | string;
+}
+
+export interface MultiSelectOptions {
+  message: string;
+  choices: Array<{ name: string; value: any; checked?: boolean }>;
+}
+
+export class UI {
+  static success(message: string): void {
+    console.log(chalk.green('✓'), message);
+  }
+
+  static error(message: string): void {
+    console.error(chalk.red('✗'), message);
+  }
+
+  static warning(message: string): void {
+    console.warn(chalk.yellow('⚠'), message);
+  }
+
+  static info(message: string): void {
+    console.log(chalk.blue('ℹ'), message);
+  }
+
+  static header(message: string): void {
+    console.log(chalk.bold.cyan(message));
+  }
+
+  static async confirm(options: ConfirmOptions): Promise<boolean> {
+    const { message, default: defaultValue = false } = options;
+    
+    const answers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message,
+        default: defaultValue
+      }
+    ]);
+    
+    return answers.confirmed;
+  }
+
+  static async select(options: SelectOptions): Promise<any> {
+    const { message, choices, default: defaultValue } = options;
+    
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selected',
+        message,
+        choices,
+        default: defaultValue
+      }
+    ]);
+    
+    return answers.selected;
+  }
+
+  static async input(options: InputOptions): Promise<string> {
+    const { message, default: defaultValue, validate } = options;
+    
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'input',
+        message,
+        default: defaultValue,
+        validate: validate ? (input: string) => {
+          const result = validate(input);
+          if (typeof result === 'boolean') {
+            return result;
+          }
+          return result || true;
+        } : undefined
+      }
+    ]);
+    
+    return answers.input;
+  }
+
+  static async multiSelect(options: MultiSelectOptions): Promise<any[]> {
+    const { message, choices } = options;
+    
+    const answers = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selected',
+        message,
+        choices
+      }
+    ]);
+    
+    return answers.selected;
+  }
+
+  static table(headers: string[], rows: string[][]): void {
+    const columnWidths = headers.map((header, index) => {
+      const maxRowWidth = Math.max(...rows.map(row => row[index]?.length || 0));
+      return Math.max(header.length, maxRowWidth);
+    });
+
+    const formatRow = (row: string[]) => {
+      return row.map((cell, index) => cell.padEnd(columnWidths[index])).join(' | ');
+    };
+
+    const separator = columnWidths.map(width => '-'.repeat(width)).join('-+-');
+
+    console.log(formatRow(headers));
+    console.log(separator);
+    rows.forEach(row => console.log(formatRow(row)));
+  }
+
+  static list(items: string[], bullet: string = '•'): void {
+    items.forEach(item => console.log(`${bullet} ${item}`));
+  }
+
+  static divider(char: string = '-', length: number = 50): void {
+    console.log(char.repeat(length));
+  }
+
+  static highlight(text: string, color: 'green' | 'yellow' | 'red' | 'blue' | 'cyan' = 'cyan'): void {
+    const colors = {
+      green: chalk.green,
+      yellow: chalk.yellow,
+      red: chalk.red,
+      blue: chalk.blue,
+      cyan: chalk.cyan
+    };
+    console.log(colors[color](text));
+  }
+
+  static progress(current: number, total: number, message: string = ''): void {
+    const percentage = Math.round((current / total) * 100);
+    const barLength = 30;
+    const filledLength = Math.round((barLength * current) / total);
+    const bar = '█'.repeat(filledLength) + '-'.repeat(barLength - filledLength);
+    
+    process.stdout.write(`\\r[${bar}] ${percentage}% ${message}`);
+    
+    if (current === total) {
+      process.stdout.write('\\n');
+    }
+  }
+}

package/src/workspace/config.ts

@@ -0,0 +1,86 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+export interface Config {
+  provider: string;
+  endpoint: string;
+  model: string;
+  apiKey?: string;
+  dryRun: boolean;
+}
+
+export class ConfigManager {
+  private workspacePath: string;
+  private configPath: string;
+
+  constructor(workspacePath: string) {
+    this.workspacePath = workspacePath;
+    this.configPath = path.join(workspacePath, 'config.json');
+  }
+
+  async loadConfig(): Promise<Config> {
+    try {
+      if (await fs.pathExists(this.configPath)) {
+        const config = await fs.readJson(this.configPath);
+        return this.mergeWithEnv(config);
+      }
+    } catch (error) {
+      console.warn('Failed to load config, creating default:', error);
+    }
+
+    return this.createDefaultConfig();
+  }
+
+  async saveConfig(config: Config): Promise<void> {
+    await fs.writeJson(this.configPath, config, { spaces: 2 });
+  }
+
+  async updateConfig(updates: Partial<Config>): Promise<Config> {
+    const config = await this.loadConfig();
+    const newConfig = { ...config, ...updates };
+    await this.saveConfig(newConfig);
+    return newConfig;
+  }
+
+  getApiKey(config: Config): string {
+    const envApiKey = process.env.BYTARCH_API_KEY;
+    if (envApiKey) {
+      return envApiKey;
+    }
+    
+    if (config.apiKey) {
+      return config.apiKey;
+    }
+    
+    throw new Error('BYTARCH API key not found. Set BYTARCH_API_KEY environment variable or configure in .genie-cli/config.json');
+  }
+
+  private mergeWithEnv(config: Partial<Config>): Config {
+    const defaultConfig = this.createDefaultConfig();
+    const mergedConfig = { ...defaultConfig, ...config };
+
+    if (process.env.BYTARCH_API_KEY) {
+      mergedConfig.apiKey = process.env.BYTARCH_API_KEY;
+    }
+
+    if (process.env.BYTARCH_ENDPOINT) {
+      mergedConfig.endpoint = process.env.BYTARCH_ENDPOINT;
+    }
+
+    if (process.env.BYTARCH_MODEL) {
+      mergedConfig.model = process.env.BYTARCH_MODEL;
+    }
+
+    return mergedConfig;
+  }
+
+  private createDefaultConfig(): Config {
+    return {
+      provider: 'bytarch',
+      endpoint: 'https://api.bytarch.dpdns.org/openai/v1/chat/completions',
+      model: 'gpt-5-nano',
+      apiKey: '',
+      dryRun: true
+    };
+  }
+}

package/src/workspace/edits.ts

@@ -0,0 +1,106 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+export interface FileEdit {
+  id: string;
+  path: string;
+  description: string;
+  rationale: string;
+  patch: string;
+  status: 'pending' | 'accepted' | 'rejected' | 'applied';
+  createdAt: string;
+  updatedAt: string;
+}
+
+export class EditManager {
+  private workspacePath: string;
+  private editsPath: string;
+
+  constructor(workspacePath: string) {
+    this.workspacePath = workspacePath;
+    this.editsPath = path.join(workspacePath, 'edits');
+  }
+
+  async ensureEditsDir(): Promise<void> {
+    await fs.ensureDir(this.editsPath);
+  }
+
+  async saveEdit(edit: FileEdit): Promise<void> {
+    await this.ensureEditsDir();
+    edit.updatedAt = new Date().toISOString();
+    const editPath = path.join(this.editsPath, `${edit.id}.json`);
+    await fs.writeJson(editPath, edit, { spaces: 2 });
+  }
+
+  async loadEdit(editId: string): Promise<FileEdit | null> {
+    await this.ensureEditsDir();
+    const editPath = path.join(this.editsPath, `${editId}.json`);
+    
+    try {
+      if (await fs.pathExists(editPath)) {
+        return await fs.readJson(editPath);
+      }
+    } catch (error) {
+      console.warn(`Failed to load edit ${editId}:`, error);
+    }
+    
+    return null;
+  }
+
+  async listEdits(): Promise<FileEdit[]> {
+    await this.ensureEditsDir();
+    
+    try {
+      const files = await fs.readdir(this.editsPath);
+      const jsonFiles = files.filter(file => file.endsWith('.json'));
+      
+      const edits: FileEdit[] = [];
+      for (const file of jsonFiles) {
+        const editPath = path.join(this.editsPath, file);
+        try {
+          const edit = await fs.readJson(editPath);
+          edits.push(edit);
+        } catch (error) {
+          console.warn(`Failed to load edit file ${file}:`, error);
+        }
+      }
+      
+      return edits.sort((a, b) => 
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+      );
+    } catch (error) {
+      console.warn('Failed to list edits:', error);
+      return [];
+    }
+  }
+
+  async updateEditStatus(editId: string, status: FileEdit['status']): Promise<FileEdit | null> {
+    const edit = await this.loadEdit(editId);
+    if (!edit) return null;
+    
+    edit.status = status;
+    edit.updatedAt = new Date().toISOString();
+    await this.saveEdit(edit);
+    return edit;
+  }
+
+  async deleteEdit(editId: string): Promise<void> {
+    await this.ensureEditsDir();
+    const editPath = path.join(this.editsPath, `${editId}.json`);
+    
+    try {
+      await fs.remove(editPath);
+    } catch (error) {
+      console.warn(`Failed to delete edit ${editId}:`, error);
+    }
+  }
+
+  async getPendingEdits(): Promise<FileEdit[]> {
+    const edits = await this.listEdits();
+    return edits.filter(edit => edit.status === 'pending' || edit.status === 'accepted');
+  }
+
+  generateEditId(): string {
+    return `edit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+}