vcode-cli 1.0.5 → 2.0.0

package/lib/auth/index.js

@@ -0,0 +1,120 @@
+import keytar from 'keytar';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+const SERVICE_NAME = 'vynthen-vcode';
+const ACCOUNT_NAME = 'vynthen-credentials';
+
+export interface VynthenCredentials {
+  email: string;
+  token: string;
+  plan: string;
+  expiresAt: number;
+}
+
+export async function login(): Promise<void> {
+  console.log(chalk.hex('#a855f7').bold('\n  🔐 V Code Login\n'));
+  console.log(chalk.gray('  Connect with your Vynthen account\n'));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'email',
+      message: chalk.white('  Email:'),
+      validate: (input: string) => {
+        if (!input.includes('@')) return 'Please enter a valid email';
+        return true;
+      }
+    },
+    {
+      type: 'password',
+      name: 'password',
+      message: chalk.white('  Password:'),
+      mask: '*',
+      validate: (input: string) => {
+        if (input.length < 1) return 'Password required';
+        return true;
+      }
+    }
+  ]);
+
+  try {
+    console.log(chalk.gray('\n  Authenticating...'));
+    
+    const response = await fetch('https://vynthen.com/api/auth/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email: answers.email, password: answers.password })
+    });
+
+    if (!response.ok) {
+      const err = await response.json();
+      console.log(chalk.red(`\n  ✗ ${err.message || 'Authentication failed'}\n`));
+      process.exit(1);
+    }
+
+    const data = await response.json();
+    
+    // Store credentials in keychain
+    const credentials: VynthenCredentials = {
+      email: answers.email,
+      token: data.token,
+      plan: data.plan || 'free',
+      expiresAt: Date.now() + (8 * 60 * 60 * 1000) // 8 hours
+    };
+
+    await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, JSON.stringify(credentials));
+    
+    console.log(chalk.green('\n  ✓ Logged in successfully!'));
+    console.log(chalk.gray(`  Plan: ${chalk.cyan(credentials.plan)}`));
+    console.log(chalk.gray(`  Token expires in 8 hours\n`));
+    
+  } catch (error) {
+    console.log(chalk.red(`\n  ✗ Connection error. Please try again.\n`));
+    process.exit(1);
+  }
+}
+
+export async function logout(): Promise<void> {
+  const deleted = await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
+  
+  if (deleted) {
+    console.log(chalk.green('\n  ✓ Logged out successfully\n'));
+  } else {
+    console.log(chalk.gray('\n  Already logged out\n'));
+  }
+}
+
+export async function getCredentials(): Promise<VynthenCredentials | null> {
+  const stored = await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
+  if (!stored) return null;
+  
+  try {
+    const creds: VynthenCredentials = JSON.parse(stored);
+    
+    // Check if token expired
+    if (Date.now() > creds.expiresAt) {
+      console.log(chalk.yellow('\n  ⚠ Token expired. Please run vcode login\n'));
+      return null;
+    }
+    
+    return creds;
+  } catch {
+    return null;
+  }
+}
+
+export async function getToken(): Promise<string | null> {
+  const creds = await getCredentials();
+  return creds?.token || null;
+}
+
+export async function getUser(): Promise<{ email: string; plan: string } | null> {
+  const creds = await getCredentials();
+  if (!creds) return null;
+  return { email: creds.email, plan: creds.plan };
+}
+
+export function isAuthenticated(): boolean {
+  return getCredentials() !== null;
+}

package/lib/byte/index.js

@@ -0,0 +1,207 @@
+import chalk from 'chalk';
+
+export type ByteMood = 'idle' | 'thinking' | 'working' | 'success' | 'error' | 'waiting' | 'celebrating';
+
+const ASCII_ARTS: Record<ByteMood, string> = {
+  idle: `
+      /\\_____/\\
+     /  o   o  \\
+    ( ==  ^  == )
+     )         (
+    (           )
+   ( (  )   (  ) )
+   (__(__)__(__)_)
+`,
+  thinking: `
+      /\\_____/\\
+     /  ?   ?  \\
+    ( ==  o  == )
+     )         (
+    (    o     )
+   ( (  )   (  ) )
+   (__(__)__(__)_)
+     meow?
+`,
+  working: `
+      /\\_____/\\
+     /  O   O  \\
+    ( ==  ^  == )
+     )____|____(
+    (  typing  )
+   ( (  )   (  ) )
+   (__(__)__(__)_)
+`,
+  success: `
+      /\\_____/\\
+     /  ^   ^  \\
+    ( ==  v  == )
+     )         (
+    (  victory! )
+   ( (  )   (  ) )
+   (__(__)__(__)_)
+     purr!
+`,
+  error: `
+      /\\_____/\\
+     /  X   X  \\
+    ( ==  o  == )
+     )_________(
+    (  oops...  )
+   ( (  )   (  ) )
+   (__(__)__(__)_)
+`,
+  waiting: `
+      /\\_____/\\
+     /  >   <  \\
+    ( ==  ^  == )
+     )_____|____(
+    (  you sure? )
+   ( (  )   (  ) )
+   (__(__)__(__)_)
+`,
+  celebrating: `
+      /\\_____/\\
+     /  ^   ^  \\
+    ( ==  v  == )
+     )  (^o^)  (
+    (  purr!!   )
+   ( (  )   (  ) )
+   (__(__)__(__)_)
+     yay!
+`,
+};
+
+const MESSAGES: Record<ByteMood, string[]> = {
+  idle: [
+    'ready when you are',
+    'waiting for your command~',
+    '*stretch* what shall we build?',
+    '*~*~',
+  ],
+  thinking: [
+    'hmm let me think...',
+    'processing...',
+    'give me a moment~',
+    'thinking hard!',
+  ],
+  working: [
+    'on it...',
+    'working my magic~',
+    'be right back...',
+    'typing away...',
+  ],
+  success: [
+    'done! purr~',
+    'all set!',
+    'mission complete!',
+    'purrfect!',
+  ],
+  error: [
+    'uh oh...',
+    'that didn\'t work...',
+    'oopsie~',
+    'need to try again...',
+  ],
+  waiting: [
+    'you sure about this?',
+    'waiting for your okay~',
+    'what do you think?',
+    'approve?',
+  ],
+  celebrating: [
+    'we did it!!',
+    'purrfect job!',
+    'amazing!',
+    'woohoo!',
+  ],
+};
+
+export class Byte {
+  private currentMood: ByteMood = 'idle';
+  private showCompanion: boolean = true;
+  private animationFrame: NodeJS.Timeout | null = null;
+
+  constructor(showCompanion: boolean = true) {
+    this.showCompanion = showCompanion;
+  }
+
+  setCompanion(enabled: boolean) {
+    this.showCompanion = enabled;
+  }
+
+  getMood(): ByteMood {
+    return this.currentMood;
+  }
+
+  setMood(mood: ByteMood) {
+    this.currentMood = mood;
+  }
+
+  getArt(): string {
+    return ASCII_ARTS[this.currentMood];
+  }
+
+  getMessage(): string {
+    const messages = MESSAGES[this.currentMood];
+    return messages[Math.floor(Math.random() * messages.length)];
+  }
+
+  show(mood?: ByteMood) {
+    if (!this.showCompanion) return;
+    
+    if (mood) this.currentMood = mood;
+    
+    const art = chalk.gray(ASCII_ARTS[this.currentMood]);
+    const message = chalk.cyan(this.getMessage());
+    
+    console.log(art);
+    console.log(`  ${message}`);
+  }
+
+  say(text: string, mood?: ByteMood) {
+    if (!this.showCompanion) {
+      console.log(chalk.cyan(`  ${text}`));
+      return;
+    }
+    
+    if (mood) this.currentMood = mood;
+    
+    const art = chalk.gray(ASCII_ARTS[this.currentMood]);
+    console.log(art);
+    console.log(`  ${chalk.cyan(text)}`);
+  }
+
+  animate(mood: ByteMood, duration: number = 2000) {
+    if (!this.showCompanion) return;
+    
+    this.currentMood = mood;
+    
+    const frames: ByteMood[] = [mood, 'idle'];
+    let frameIndex = 0;
+    
+    this.animationFrame = setInterval(() => {
+      frameIndex = (frameIndex + 1) % frames.length;
+      this.currentMood = frames[frameIndex];
+    }, duration / 2);
+
+    setTimeout(() => {
+      this.stopAnimation();
+      this.currentMood = 'idle';
+    }, duration);
+  }
+
+  stopAnimation() {
+    if (this.animationFrame) {
+      clearInterval(this.animationFrame);
+      this.animationFrame = null;
+    }
+  }
+
+  clear() {
+    if (!this.showCompanion) return;
+    process.stdout.write('\x1b[9A'); // Move up lines
+    process.stdout.write('\x1b[J'); // Clear to end of screen
+  }
+}
+
+export const byte = new Byte();

package/lib/commands/add.js

@@ -0,0 +1,9 @@
+import chalk from 'chalk';
+import { contextManager } from '../agent/context.js';
+import * as path from 'path';
+
+export async function addFile(filePath: string) {
+  const fullPath = path.resolve(filePath);
+  await contextManager.addFile(fullPath);
+  console.log(chalk.green(`\n  ✓ Added ${fullPath} to context\n`));
+}

package/lib/commands/clear.js

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+import { contextManager } from '../agent/context.js';
+
+export async function clearContext() {
+  contextManager.clearConversation();
+  contextManager.clearFiles();
+  console.log(chalk.green('\n  ✓ Context cleared\n'));
+}

package/lib/commands/config.js

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import { setCompanionEnabled } from '../ui/byte.js';
+
+export async function config(opts: { companion?: boolean; noCompanion?: boolean }) {
+  const configDir = path.join(process.env.HOME || '', '.vcode');
+  const configPath = path.join(configDir, 'config.json');
+  
+  // Ensure directory exists
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  
+  // Load existing config
+  let config: Record<string, any> = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch {}
+  }
+  
+  // Update config
+  if (opts.companion !== undefined) {
+    config.companion = opts.companion;
+    setCompanionEnabled(opts.companion);
+  }
+  if (opts.noCompanion !== undefined) {
+    config.companion = !opts.noCompanion;
+    setCompanionEnabled(!opts.noCompanion);
+  }
+  
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  
+  console.log(chalk.green('\n  ✓ Settings saved\n'));
+  console.log(chalk.gray(`  Config: ${configPath}\n`));
+}

package/lib/commands/help.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+
+const COMMANDS = [
+  { cmd: 'vcode login', desc: 'Authenticate with Vynthen email and password' },
+  { cmd: 'vcode logout', desc: 'Clear stored credentials' },
+  { cmd: 'vcode status', desc: 'Show user info and plan tier' },
+  { cmd: 'vcode', desc: 'Start interactive agent in current folder' },
+  { cmd: 'vcode history', desc: 'Show session history' },
+  { cmd: 'vcode undo', desc: 'Undo last file operation' },
+  { cmd: 'vcode clear', desc: 'Clear conversation context' },
+  { cmd: 'vcode add <file>', desc: 'Add file to context' },
+  { cmd: 'vcode config --no-companion', desc: 'Disable Byte companion' },
+];
+
+export async function showHelp() {
+  console.log(chalk.hex('#a855f7').bold('\n  📖 V Code Commands\n'));
+  
+  for (const cmd of COMMANDS) {
+    console.log(chalk.white(`  ${cmd.cmd.padEnd(25)} ${cmd.desc}`));
+  }
+  
+  console.log(chalk.gray('\n  Examples:'));
+  console.log(chalk.gray('    vcode login'));
+  console.log(chalk.gray('    vcode add src/index.ts'));
+  console.log(chalk.gray('    vcode config --no-companion'));
+  console.log('');
+}

package/lib/commands/history.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import { getOperationHistory } from '../tools/filesystem.js';
+
+export async function history() {
+  const ops = getOperationHistory();
+  
+  if (ops.length === 0) {
+    console.log(chalk.yellow('\n  No operations in history\n'));
+    return;
+  }
+  
+  console.log(chalk.hex('#a855f7').bold('\n  📜 Session History\n'));
+  
+  for (const op of ops.slice(0, 20)) {
+    const time = new Date(op.timestamp).toLocaleTimeString();
+    const icon = {
+      read: '📄',
+      write: '✏️',
+      delete: '🗑️',
+      create_dir: '📁',
+      rename: '📝',
+      move: '➡️'
+    }[op.type] || '•';
+    
+    console.log(chalk.gray(`  ${time} ${icon} ${op.type}: ${op.path}`));
+  }
+  
+  console.log('');
+}

package/lib/commands/start.js

@@ -1,145 +1,24 @@
-/**
- * V Code — Start Command.
- * Launches the bridge, shows animated logo, connects to Vynthen.
- */
-
 import chalk from 'chalk';
-import { showLogo, startLogoAnimation } from '../logo.js';
-import { getToken, isTokenExpired, getUser } from '../keychain.js';
-import { Bridge } from '../bridge.js';
-import { setSessionApproveAll } from '../permissions.js';
-import { spawn } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-
-export async function start(opts = {}) {
-  const token = await getToken();
+import { showLogoOnce } from '../ui/logo.js';
+import { showByteIdle } from '../ui/byte.js';
+import { getUser } from '../auth/index.js';
+import { startAgent } from '../agent/loop.js';
 
-  if (!token) {
-    console.log(chalk.red('\n  ✗ Not authenticated. Run `vcode login` first.\n'));
-    process.exit(1);
-  }
-
-  if (isTokenExpired(token)) {
-    console.log(chalk.red('\n  ✗ Token expired. Run `vcode login` to re-authenticate.\n'));
+export async function start(opts: { approveAll?: boolean } = {}) {
+  showLogoOnce();
+  
+  const user = await getUser();
+  if (!user) {
+    console.log(chalk.red('\n  ✗ Not authenticated. Run vcode login first.\n'));
     process.exit(1);
   }
-
-  if (opts.approveAll) {
-    setSessionApproveAll(true);
-    console.log(chalk.yellow('\n  ⚠ Auto-approve mode enabled. All operations will be approved automatically.\n'));
-  }
-
-  const stopAnimation = startLogoAnimation();
-  await new Promise(resolve => setTimeout(resolve, 2500));
-  stopAnimation();
-
-  const user = await getUser();
-  
-  const serverUrl = process.env.VCODE_WS_URL || 
-    (process.env.VCODE_LOCAL === 'false' ? 'wss://vynthen.com/api/vcode-ws' : 'ws://localhost:3001');
-  const displayUrl = process.env.VCODE_LOCAL === 'false' ? 'vynthen.com' : 'localhost:3001';
-  const autoStartServer = opts.server !== false && opts.server !== undefined;
   
-  // Try to find the server script
-  const serverScript = path.join(process.cwd(), 'lib', 'server.js');
-  const serverExists = fs.existsSync(serverScript);
-
-  const globalLibDir = path.join(path.dirname(process.execPath), '..', 'lib', 'node_modules', 'vcode-cli');
-  const globalServerScript = path.join(globalLibDir, 'lib', 'server.js');
-  const finalServerScript = serverExists ? serverScript : (fs.existsSync(globalServerScript) ? globalServerScript : null);
+  console.log(chalk.gray(`  Project: ${process.cwd()}`));
+  console.log(chalk.gray(`  User: ${user.email}`));
+  console.log(chalk.gray(`  Plan: ${user.plan}`));
+  console.log('');
   
-  // Start the WebSocket server automatically if not already running
-  let serverProcess = null;
+  showByteIdle();
   
-  if (autoStartServer && finalServerScript) {
-    console.log(chalk.gray(`  Server script: ${finalServerScript}`));
-    console.log(chalk.gray('  Starting V Code WebSocket server...'));
-    
-    serverProcess = spawn('node', [finalServerScript], {
-      stdio: 'inherit',
-      detached: false
-    });
-    
-    // Wait for server to start
-    await new Promise(resolve => setTimeout(resolve, 1500));
-    
-    if (serverProcess.killed || !serverProcess.pid) {
-      console.log(chalk.yellow('\n  ⚠ Could not start WebSocket server. Make sure port 3001 is available.\n'));
-    } else {
-      console.log(chalk.green('  ✓ WebSocket server started on port 3001'));
-    }
-  }
-
-  console.log('');
-  console.log(chalk.gray('  ─────────────────────────────────────────────────────'));
-  console.log(chalk.hex('#a855f7').bold('               Vynthen V Code — Bridge'));
-  console.log(chalk.gray('  ─────────────────────────────────────────────────────'));
-  console.log('');
-  console.log(chalk.white('  User:     ') + chalk.cyan(user || 'authenticated'));
-  console.log(chalk.white('  Mode:     ') + chalk.gray(opts.approveAll ? 'Auto-approve' : 'Human-in-the-loop'));
-  console.log(chalk.white('  Endpoint: ') + chalk.gray(displayUrl));
-  console.log('');
-
-  let currentWorkingDir = process.cwd();
-  let terminalOutput = [];
-
-  const bridge = new Bridge({
-    onStatusChange: (status) => {
-      switch (status) {
-        case 'connected':
-          break;
-        case 'reconnecting':
-          break;
-        case 'auth_failed':
-        case 'token_expired':
-          process.exit(1);
-          break;
-        case 'disconnected':
-          break;
-      }
-    },
-    onOperation: (opType, params) => {
-    },
-    onError: (err) => {
-    },
-    onWorkingDirChange: (path) => {
-      currentWorkingDir = path;
-      console.log(chalk.gray(`  📁 Working directory: ${path}`));
-    },
-    onTerminalOutput: (output) => {
-      terminalOutput.push(output);
-      if (terminalOutput.length > 100) {
-        terminalOutput = terminalOutput.slice(-100);
-      }
-      process.stdout.write(output);
-    },
-  });
-
-  const shutdown = () => {
-    console.log(chalk.gray('\n\n  Shutting down V Code bridge...'));
-    bridge.disconnect();
-    if (serverProcess) {
-      serverProcess.kill();
-    }
-    console.log(chalk.gray(`  Session duration: ${bridge.getUptime()}`));
-    console.log(chalk.gray(`  Operations handled: ${bridge.operationCount}`));
-    console.log(chalk.green('  Goodbye! 👋\n'));
-    process.exit(0);
-  };
-
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
-
-  try {
-    await bridge.connect();
-  } catch (err) {
-    console.log(chalk.red(`  ✗ ${err.message}\n`));
-    if (serverProcess) {
-      serverProcess.kill();
-    }
-    process.exit(1);
-  }
-
-  await new Promise(() => {});
-}
+  await startAgent(opts);
+}

package/lib/commands/undo.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { clearHistory, getLastOperation, readFile, writeFile } from '../tools/filesystem.js';
+
+export async function undo() {
+  const lastOp = getLastOperation();
+  
+  if (!lastOp) {
+    console.log(chalk.yellow('\n  No operations to undo\n'));
+    return;
+  }
+  
+  if (lastOp.type === 'write' && lastOp.content) {
+    // Revert to original content
+    await writeFile(lastOp.path, lastOp.content, false);
+    console.log(chalk.green(`\n  ✓ Reverted ${lastOp.path}\n`));
+  } else if (lastOp.type === 'delete') {
+    console.log(chalk.yellow('\n  Cannot undo delete operation\n'));
+  } else {
+    console.log(chalk.yellow(`\n  Cannot undo ${lastOp.type} operation\n`));
+  }
+  
+  clearHistory();
+}