bytarch-cli 0.1.0 → 0.1.1

package/bin/bytarch-cli.js

@@ -1,3 +1,16 @@
 #!/usr/bin/env node
 
-require('../dist/index.js');
+require('../dist/index.js');
+
+// If invoked with no subcommands, enter chat mode by default
+try {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0) {
+    const chat = require('../dist/chat');
+    chat.runChat().catch((e) => {
+      console.error('Chat mode failed:', e);
+    });
+  }
+} catch (e) {
+  // ignore
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bytarch-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "AI-powered CLI for project planning and code editing using BYTARCH OpenAI-compatible API",
   "main": "dist/index.js",
   "bin": {

package/src/chat.ts

@@ -0,0 +1,124 @@
+import * as readline from 'readline';
+import { BytarchProvider } from './provider/bytarch';
+import { ConfigManager } from './workspace/config';
+import { EditManager } from './workspace/edits';
+import { UI } from './ui/prompts';
+import { extractJsonFromResponse } from './provider/evaluation';
+
+// Simple chat-first entry point with an explicit /apply flow inside chat.
+export async function runChat(): Promise<void> {
+  const workspacePath = process.cwd() + '/.genie-cli';
+  const config = await new ConfigManager(workspacePath).loadConfig();
+  const apiKey = new ConfigManager(workspacePath).getApiKey(config);
+  const provider = new BytarchProvider(config.endpoint, config.model, apiKey);
+  const editManager = new EditManager(workspacePath);
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  UI.header('BYTARCH AI Chat (type your message; use /apply, /list, /help)');
+
+  const ask = (q: string) => new Promise<string>(resolve => rl.question(q, ans => resolve(ans)));
+
+  // Simple REPL-like loop
+  while (true) {
+    const input = await ask('You: ');
+    const text = (input || '').trim();
+    if (!text) break;
+
+    // Command handling
+    if (text.startsWith('/')) {
+      const [cmd, ...args] = text.slice(1).split(' ');
+      switch (cmd.toLowerCase()) {
+        case 'help':
+          UI.info('Commands:');
+          UI.list([
+            '/help - show this help',
+            '/list - list pending/available edits',
+            '/apply [id|all] - apply a specific patch or all accepted patches',
+            '/exit - quit chat'
+          ]);
+          break;
+        case 'list': {
+          const edits = await editManager.listEdits();
+          if (edits.length === 0) {
+            UI.info('No edits found.');
+          } else {
+            edits.forEach(e => {
+              console.log(`- ${e.id} | ${e.path} | ${e.status} | ${e.description}`);
+            });
+          }
+          break;
+        }
+        case 'apply': {
+          // Apply one or more edits. If 'all', apply all accepted edits; if id, apply that patch.
+          const target = args.join(' ').trim();
+          const patches = await editManager.getPendingEdits();
+          const toApply = target ? patches.filter(p => p.id === target) : patches.filter(p => p.status === 'accepted');
+          if (toApply.length === 0) {
+            UI.warning('No edits available to apply for the given selector. Use /list to inspect edits.');
+            break;
+          }
+          const { Patcher } = await import('./fs/patcher');
+          const patcher = new Patcher(process.cwd());
+          for (const edit of toApply) {
+            UI.header(`Applying ${edit.path} (${edit.id})`);
+            const result = await patcher.applyPatch(edit);
+            if (result.success) {
+              await editManager.updateEditStatus(edit.id, 'applied');
+              UI.success(`Applied ${edit.path} (${result.changes ?? 0} changes)`);
+            } else {
+              UI.error(`Failed to apply ${edit.path}: ${result.error}`);
+            }
+          }
+          break;
+        }
+        case 'exit':
+        case 'quit':
+        case 'close':
+          rl.close();
+          return;
+        default:
+          UI.warning('Unknown chat command. Type /help for options.');
+      }
+      continue;
+    }
+
+    // Regular chat message: send to AI and handle patch results
+    try {
+      const messages = [
+        { role: 'system', content: 'You are a code-editing AI assistant. Return a JSON patch object when you want to edit a file.' },
+        { role: 'user', content: text }
+      ];
+      const response = await provider.chat(messages as any);
+      // Try to parse as JSON patch
+      try {
+        const patchObj = extractJsonFromResponse(response);
+        // Expect { path, patch, description, rationale }
+        if (patchObj && patchObj.path && patchObj.patch) {
+          const edit = {
+            id: editManager.generateEditId(),
+            path: patchObj.path,
+            description: patchObj.description || '',
+            rationale: patchObj.rationale || '',
+            patch: patchObj.patch,
+            status: 'pending' as const,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+          };
+          await editManager.saveEdit(edit as any);
+          UI.success(`New patch created for ${patchObj.path} (id: ${edit.id})`);
+          UI.info(`Type /apply ${edit.id} to apply, or /list to view edits.`);
+        } else {
+          UI.info(`AI: ${response}`);
+        }
+      } catch {
+        // Not a JSON patch, just print the AI response
+        UI.info(`AI: ${response}`);
+      }
+    } catch (err) {
+      UI.error(`AI error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  rl.close();
+}
+
+export default runChat;