vcode-cli 1.0.4 → 2.0.0

package/LICENSE

@@ -1,21 +1,24 @@
-MIT License
-
-Copyright (c) 2026 Vynthen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+This software is proprietary and owned exclusively by Tibebe Solomon and Vynthen
+
+NO PART OF THIS SOFTWARE may be copied, modified, distributed, sublicensed, sold, or used in any commercial or non-commercial product without explicit written permission from Tibebe Solomon.
+
+REVERSE ENGINEERING PROHIBITED:
+Reverse engineering, decompilation, and disassembly are strictly prohibited. You agree not to reverse engineer, decompile, or disassemble any part of this software.
+
+UNAUTHORIZED USE:
+Any unauthorized use will result in immediate legal action under international copyright law and the Digital Millennium Copyright Act (DMCA).
+
+PERSONAL USE ONLY:
+This software is provided for personal use only by licensed end users. Commercial use requires a separate written agreement with Tibebe Solomon.
+
+PENALTIES:
+Violators are subject to civil and criminal penalties including damages up to $150,000 per violation under 17 U.S.C. § 504 (Statutory Damages for Copyright Infringement).
+
+ALL RIGHTS RESERVED WORLDWIDE:
+© 2026 Tibebe Solomon / Vynthen. All rights reserved.
+
+DISCLAIMER:
+THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. THE AUTHOR DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+LIMITATION OF LIABILITY:
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/bin/vcode.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 /**
- * V Code CLI — Vynthen Local Bridge
- * Entry point for all CLI commands.
+ * V Code CLI 2.0 — Terminal AI Coding Agent
+ * Powered by Vynthen
  */
 
 import { Command } from 'commander';
@@ -18,48 +18,20 @@ const program = new Command();
 
 program
   .name('vcode')
-  .description('Connect your local machine to Vynthen V Code')
+  .description('V Code — Terminal AI Coding Agent powered by Vynthen')
   .version(pkg.version, '-v, --version');
 
 program
   .command('login')
-  .description('Authenticate with your Vynthen account')
+  .description('Authenticate with Vynthen email and password')
   .action(async () => {
     const { login } = await import('../lib/commands/login.js');
     await login();
   });
 
-program
-  .command('start')
-  .description('Start the V Code bridge and connect to Vynthen')
-  .option('--approve-all', 'Auto-approve all operations for this session')
-  .option('--server', 'Auto-start the WebSocket server (default: true)', true)
-  .option('--local', 'Use local WebSocket server (default, use --no-local for remote)', true)
-  .action(async (opts) => {
-    if (!opts.server) {
-      process.env.VCODE_WS_URL = 'ws://localhost:3001';
-    }
-    const { start } = await import('../lib/commands/start.js');
-    await start(opts);
-  });
-
-program
-  .command('serve')
-  .description('Start only the WebSocket server (no Vynthen connection)')
-  .option('--port <number>', 'Port to listen on', '3001')
-  .action(async (opts) => {
-    const { spawn } = await import('child_process');
-    const serverPath = new URL('../lib/server.js', import.meta.url);
-    const proc = spawn('node', [serverPath.pathname], {
-      stdio: 'inherit',
-      env: { ...process.env, VCODE_WS_PORT: opts.port }
-    });
-    proc.on('close', (code) => process.exit(code || 0));
-  });
-
 program
   .command('logout')
-  .description('Clear stored authentication token')
+  .description('Clear stored credentials')
   .action(async () => {
     const { logout } = await import('../lib/commands/logout.js');
     await logout();
@@ -67,17 +39,67 @@ program
 
 program
   .command('status')
-  .description('Show connection status and logged-in user')
+  .description('Show user info and plan tier')
   .action(async () => {
     const { status } = await import('../lib/commands/status.js');
     await status();
   });
 
-program.parse(process.argv);
+program
+  .command('history')
+  .description('Show session history')
+  .action(async () => {
+    const { history } = await import('../lib/commands/history.js');
+    await history();
+  });
+
+program
+  .command('undo')
+  .description('Undo last file operation')
+  .action(async () => {
+    const { undo } = await import('../lib/commands/undo.js');
+    await undo();
+  });
 
-// Show help if no command provided
-if (!process.argv.slice(2).length) {
-  const { showLogo } = await import('../lib/logo.js');
-  await showLogo(false);
-  program.outputHelp();
-}
+program
+  .command('clear')
+  .description('Clear conversation context')
+  .action(async () => {
+    const { clearContext } = await import('../lib/commands/clear.js');
+    await clearContext();
+  });
+
+program
+  .command('config')
+  .description('Configure V Code settings')
+  .option('--no-companion', 'Disable Byte companion')
+  .option('--companion', 'Enable Byte companion')
+  .action(async (opts) => {
+    const { config } = await import('../lib/commands/config.js');
+    await config(opts);
+  });
+
+program
+  .command('add')
+  .description('Add file to context')
+  .argument('<file>', 'File path to add')
+  .action(async (file) => {
+    const { addFile } = await import('../lib/commands/add.js');
+    await addFile(file);
+  });
+
+program
+  .command('help')
+  .description('Show all commands')
+  .action(async () => {
+    const { showHelp } = await import('../lib/commands/help.js');
+    await showHelp();
+  });
+
+// Default: start interactive mode
+program.action(async () => {
+  const { start } = await import('../lib/commands/start.js');
+  await start({});
+});
+
+program.parse(process.argv);

package/lib/agent/ai.js

@@ -0,0 +1,131 @@
+import { getToken } from '../auth/index.js';
+import chalk from 'chalk';
+
+const API_BASE = 'https://vynthen.com/api/vcode-proxy';
+const DEFAULT_MODEL = 'qwen/qwen3.6-plus:free';
+
+export interface AIRequest {
+  message: string;
+  context?: {
+    files?: string[];
+    projectTree?: string;
+    workingDir?: string;
+  };
+  history?: Array<{ role: 'user' | 'assistant'; content: string }>;
+}
+
+export interface AIResponse {
+  content: string;
+  reasoning?: string;
+  toolCalls?: Array<{
+    name: string;
+    params: Record<string, unknown>;
+  }>;
+}
+
+export class VCodeAI {
+  private abortController: AbortController | null = null;
+
+  async chat(request: AIRequest, onChunk?: (chunk: string) => void): Promise<AIResponse> {
+    const token = await getToken();
+    
+    if (!token) {
+      throw new Error('Not authenticated. Run vcode login first.');
+    }
+
+    this.abortController = new AbortController();
+
+    try {
+      const response = await fetch(API_BASE, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          message: request.message,
+          context: request.context,
+          history: request.history,
+          model: DEFAULT_MODEL
+        }),
+        signal: this.abortController.signal
+      });
+
+      if (!response.ok) {
+        if (response.status === 401) {
+          throw new Error('Authentication failed. Please run vcode login again.');
+        }
+        if (response.status === 429) {
+          throw new Error('Rate limited. Please wait 15 minutes and try again.');
+        }
+        throw new Error(`API error: ${response.statusText}`);
+      }
+
+      // Handle streaming response
+      if (response.body) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let content = '';
+        let reasoning = '';
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          const chunk = decoder.decode(value);
+          const lines = chunk.split('\n');
+
+          for (const line of lines) {
+            if (line.startsWith('data: ')) {
+              const data = line.slice(6);
+              
+              if (data === '[DONE]') continue;
+
+              try {
+                const parsed = JSON.parse(data);
+                
+                if (parsed.type === 'thinking') {
+                  reasoning += parsed.content;
+                  if (onChunk) onChunk(chalk.italic(chalk.gray(parsed.content)));
+                } else if (parsed.type === 'content') {
+                  content += parsed.content;
+                  if (onChunk) onChunk(parsed.content);
+                } else if (parsed.type === 'tool_call') {
+                  // Handle tool call
+                }
+              } catch {
+                // Not JSON, treat as content
+                content += data;
+                if (onChunk) onChunk(data);
+              }
+            }
+          }
+        }
+
+        return { content, reasoning };
+      }
+
+      // Non-streaming fallback
+      const data = await response.json();
+      return {
+        content: data.content || '',
+        reasoning: data.reasoning,
+        toolCalls: data.toolCalls
+      };
+
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error('Request cancelled');
+      }
+      throw error;
+    }
+  }
+
+  abort(): void {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+}
+
+export const ai = new VCodeAI();

package/lib/agent/context.js

@@ -0,0 +1,111 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getFileTree, formatFileTree, readFile } from './filesystem.js';
+
+export interface ContextFile {
+  path: string;
+  content?: string;
+  summary?: string;
+}
+
+export interface ConversationMessage {
+  role: 'user' | 'assistant';
+  content: string;
+  timestamp: number;
+}
+
+class ContextManager {
+  private conversation: ConversationMessage[] = [];
+  private contextFiles: ContextFile[] = [];
+  private projectTree: string = '';
+  private workingDir: string = '';
+
+  async initContext(workingDirectory: string): Promise<void> {
+    this.workingDir = workingDirectory;
+    this.conversation = [];
+    this.contextFiles = [];
+    
+    console.log('  Building project context...');
+    
+    // Build file tree
+    const tree = await getFileTree(workingDirectory, 4);
+    this.projectTree = formatFileTree(tree);
+    
+    // Auto-add key files
+    const keyFiles = ['package.json', 'README.md', 'tsconfig.json', 'jsconfig.json', '.env.example'];
+    
+    for (const file of keyFiles) {
+      const filePath = path.join(workingDirectory, file);
+      if (fs.existsSync(filePath)) {
+        await this.addFile(filePath);
+      }
+    }
+  }
+
+  async addFile(filePath: string): Promise<void> {
+    try {
+      const content = await readFile(filePath);
+      this.contextFiles.push({
+        path: filePath,
+        content
+      });
+    } catch (error) {
+      console.log(`  Could not read ${filePath}: ${error}`);
+    }
+  }
+
+  removeFile(filePath: string): void {
+    this.contextFiles = this.contextFiles.filter(f => f.path !== filePath);
+  }
+
+  clearFiles(): void {
+    this.contextFiles = [];
+  }
+
+  addMessage(role: 'user' | 'assistant', content: string): void {
+    this.conversation.push({
+      role,
+      content,
+      timestamp: Date.now()
+    });
+    
+    // Keep last 50 messages
+    if (this.conversation.length > 50) {
+      this.conversation.shift();
+    }
+  }
+
+  clearConversation(): void {
+    this.conversation = [];
+  }
+
+  getConversation(): ConversationMessage[] {
+    return [...this.conversation];
+  }
+
+  getContextFiles(): ContextFile[] {
+    return [...this.contextFiles];
+  }
+
+  getProjectTree(): string {
+    return this.projectTree;
+  }
+
+  getWorkingDir(): string {
+    return this.workingDir;
+  }
+
+  getContextForAI(): {
+    files: Array<{ path: string; content: string }>;
+    projectTree: string;
+    history: ConversationMessage[];
+  } {
+    return {
+      files: this.contextFiles.map(f => ({ path: f.path, content: f.content || '' })),
+      projectTree: this.projectTree,
+      history: this.conversation.slice(-10)
+    };
+  }
+}
+
+export const contextManager = new ContextManager();

package/lib/agent/loop.js

@@ -0,0 +1,237 @@
+import readline from 'readline';
+import chalk from 'chalk';
+import { getUser, getToken } from '../auth/index.js';
+import { ai } from './ai.js';
+import { contextManager } from './context.js';
+import { readFile, writeFile, deleteFile, createDirectory, renameFile, listDirectory, searchFiles, generateDiff } from '../tools/filesystem.js';
+import { runCommand, gitStatus, gitDiff, gitCommit, gitPush, gitPull } from '../tools/shell.js';
+import { askPermission, showDiffAndConfirm, showCommandAndConfirm, confirmDelete, setSessionApproveAll, resetSessionPermissions } from '../tools/permissions.js';
+import { showByteThinking, showByteWorking, showByteSuccess, showByteError, showByteWaiting, showByteCelebrating, setCompanionEnabled } from '../ui/byte.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface AgentOptions {
+  approveAll?: boolean;
+}
+
+const TOOL_DESCRIPTIONS: Record<string, string> = {
+  read_file: 'Read a file',
+  write_file: 'Write to a file',
+  delete_file: 'Delete a file',
+  create_dir: 'Create a directory',
+  rename_file: 'Rename a file',
+  list_dir: 'List directory contents',
+  run_command: 'Run a terminal command',
+  git_status: 'Check git status',
+  git_diff: 'Show git diff',
+  git_commit: 'Git commit changes',
+  git_push: 'Push to remote',
+  git_pull: 'Pull from remote',
+  search: 'Search files for pattern'
+};
+
+export async function startAgent(opts: AgentOptions = {}): Promise<void> {
+  if (opts.approveAll) {
+    setSessionApproveAll(true);
+    console.log(chalk.yellow('  ⚠ Auto-approve mode enabled\n'));
+  }
+
+  const user = await getUser();
+  if (!user) {
+    console.log(chalk.red('  ✗ Not authenticated. Run vcode login first.\n'));
+    process.exit(1);
+  }
+
+  // Load companion preference
+  try {
+    const configPath = path.join(process.env.HOME || '', '.vcode', 'config.json');
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (config.companion === false) {
+        setCompanionEnabled(false);
+      }
+    }
+  } catch {}
+
+  const workingDir = process.cwd();
+  console.log(chalk.gray(`  Project: ${workingDir}`));
+  console.log(chalk.gray(`  User: ${user.email}`));
+  console.log(chalk.gray(`  Plan: ${user.plan}\n`));
+
+  // Initialize context
+  await contextManager.initContext(workingDir);
+  console.log(chalk.green('  ✓ Context initialized\n'));
+
+  // Show interactive prompt
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const prompt = () => {
+    rl.question(chalk.hex('#a855f7')('\nvcode > '), async (input) => {
+      const command = input.trim();
+      
+      if (!command) {
+        prompt();
+        return;
+      }
+
+      if (command === 'exit' || command === 'quit') {
+        console.log(chalk.gray('\n  Goodbye! 👋\n'));
+        rl.close();
+        return;
+      }
+
+      if (command === 'clear') {
+        console.clear();
+        prompt();
+        return;
+      }
+
+      if (command === 'undo') {
+        // Undo implementation
+        console.log(chalk.yellow('  Feature coming soon\n'));
+        prompt();
+        return;
+      }
+
+      // Process through AI
+      await processUserMessage(command);
+      prompt();
+    });
+  };
+
+  prompt();
+}
+
+async function processUserMessage(message: string): Promise<void> {
+  showByteThinking();
+  
+  try {
+    contextManager.addMessage('user', message);
+    
+    const context = contextManager.getContextForAI();
+    
+    const response = await ai.chat({
+      message,
+      context: {
+        files: context.files,
+        projectTree: context.projectTree,
+        workingDir: contextManager.getWorkingDir()
+      },
+      history: context.history
+    }, (chunk) => {
+      process.stdout.write(chunk);
+    });
+    
+    console.log('\n');
+    showByteWorking();
+    
+    // Process tool calls from response
+    if (response.toolCalls) {
+      for (const toolCall of response.toolCalls) {
+        await executeToolCall(toolCall.name, toolCall.params);
+      }
+    }
+    
+    contextManager.addMessage('assistant', response.content);
+    showByteSuccess();
+    
+  } catch (error) {
+    showByteError();
+    console.log(chalk.red(`  ✗ ${error}\n`));
+  }
+}
+
+async function executeToolCall(toolName: string, params: Record<string, unknown>): Promise<void> {
+  const p = params as Record<string, string>;
+  
+  switch (toolName) {
+    case 'read_file': {
+      const content = await readFile(p.path);
+      console.log(chalk.bold.cyan(`\n  📄 ${p.path}\n`));
+      console.log(content);
+      break;
+    }
+    
+    case 'write_file': {
+      const diff = generateDiff(p.path, '', p.content);
+      const decision = await showDiffAndConfirm(p.path, diff);
+      
+      if (decision === 'approve' || decision === 'approve_all') {
+        const result = await writeFile(p.path, p.content, false);
+        if (result.success) {
+          console.log(chalk.green(`  ✓ Wrote ${p.path}`));
+        }
+      } else {
+        console.log(chalk.gray('  Skipped'));
+      }
+      break;
+    }
+    
+    case 'delete_file': {
+      const confirm = await confirmDelete(p.path);
+      if (confirm) {
+        await deleteFile(p.path);
+        console.log(chalk.green(`  ✓ Deleted ${p.path}`));
+      }
+      break;
+    }
+    
+    case 'create_dir': {
+      await createDirectory(p.path);
+      console.log(chalk.green(`  ✓ Created directory ${p.path}`));
+      break;
+    }
+    
+    case 'rename_file': {
+      const decision = await askPermission(`Rename ${p.oldPath} to ${p.newPath}?`, 'write');
+      if (decision === 'approve' || decision === 'approve_all') {
+        await renameFile(p.oldPath, p.newPath);
+        console.log(chalk.green(`  ✓ Renamed ${p.oldPath} to ${p.newPath}`));
+      }
+      break;
+    }
+    
+    case 'list_dir': {
+      const items = await listDirectory(p.path);
+      console.log(chalk.bold.cyan(`\n  📁 ${p.path}\n`));
+      for (const item of items) {
+        const icon = item.isDirectory ? '📁' : '📄';
+        console.log(`  ${icon} ${item.name}`);
+      }
+      break;
+    }
+    
+    case 'run_command': {
+      const decision = await showCommandAndConfirm(p.command);
+      if (decision === 'approve' || decision === 'approve_all') {
+        showByteWaiting();
+        const result = await runCommand(p.command);
+        if (result.stdout) console.log(result.stdout);
+        if (result.stderr) console.log(chalk.red(result.stderr));
+        if (result.success) {
+          console.log(chalk.green(`  ✓ Command completed`));
+        }
+      }
+      break;
+    }
+    
+    case 'search': {
+      const results = await searchFiles(p.path, p.pattern, p.isRegex);
+      console.log(chalk.bold.cyan(`\n  🔍 Results for "${p.pattern}" in ${p.path}\n`));
+      for (const r of results.slice(0, 20)) {
+        console.log(chalk.gray(`  ${r.file}:${r.line}`));
+        console.log(chalk.white(`    ${r.content}\n`));
+      }
+      if (results.length > 20) {
+        console.log(chalk.gray(`  ... and ${results.length - 20} more\n`));
+      }
+      break;
+    }
+    
+    default:
+      console.log(chalk.yellow(`  Unknown tool: ${toolName}`));
+  }
+}