vcode-cli 1.0.4 → 2.0.0

package/lib/logo.js

@@ -1,144 +1,81 @@
-/**
- * V Code — Retro ASCII Logo with animated blinking eyes.
- */
-
 import chalk from 'chalk';
+import { Byte, type ByteMood } from './byte/index.js';
 
-const FRAMES_OPEN = [
-  `
-  ╔═══════════════════════════════════════════════════════╗
-  ║                                                       ║
-  ║     ██╗   ██╗     ██████╗ ██████╗ ██████╗ ███████╗    ║
-  ║     ██║   ██║    ██╔════╝██╔═══██╗██╔══██╗██╔════╝    ║
-  ║     ██║   ██║    ██║     ██║   ██║██║  ██║█████╗      ║
-  ║     ╚██╗ ██╔╝    ██║     ██║   ██║██║  ██║██╔══╝      ║
-  ║      ╚████╔╝     ╚██████╗╚██████╔╝██████╔╝███████╗    ║
-  ║       ╚═══╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝    ║
-  ║                                                       ║
-  ║              ┌──────────────────────┐                  ║
-  ║              │    ◉            ◉    │                  ║
-  ║              │         ───         │                  ║
-  ║              └──────────────────────┘                  ║
-  ║                                                       ║
-  ╚═══════════════════════════════════════════════════════╝`,
-];
-
-const FRAMES_BLINK = [
-  `
-  ╔═══════════════════════════════════════════════════════╗
-  ║                                                       ║
-  ║     ██╗   ██╗     ██████╗ ██████╗ ██████╗ ███████╗    ║
-  ║     ██║   ██║    ██╔════╝██╔═══██╗██╔══██╗██╔════╝    ║
-  ║     ██║   ██║    ██║     ██║   ██║██║  ██║█████╗      ║
-  ║     ╚██╗ ██╔╝    ██║     ██║   ██║██║  ██║██╔══╝      ║
-  ║      ╚████╔╝     ╚██████╗╚██████╔╝██████╔╝███████╗    ║
-  ║       ╚═══╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝    ║
-  ║                                                       ║
-  ║              ┌──────────────────────┐                  ║
-  ║              │    ━            ━    │                  ║
-  ║              │         ───         │                  ║
-  ║              └──────────────────────┘                  ║
-  ║                                                       ║
-  ╚═══════════════════════════════════════════════════════╝`,
-];
+const V_CODE_LOGO = `
+ ██████╗ ██████╗ ███████╗███╗   ███╗███████╗███╗   ██╗
+██╔════╝██╔═══██╗██╔════╝████╗ ████║██╔════╝████╗  ██║
+██║     ██║   ██║█████╗  ██╔████╔██║█████╗  ██╔██╗ ██║
+██║     ██║   ██║██╔══╝  ██║╚██╔╝██║██╔══╝  ██║╚██╗██║
+╚██████╗╚██████╔╝███████╗██║ ╚═╝ ██║███████╗██║ ╚████║
+ ╚═════╝ ╚═════╝ ╚══════╝╚═╝     ╚═╝╚══════╝╚═╝  ╚═══╝
+`;
 
-const FRAMES_LOOK_LEFT = [
-  `
-  ╔═══════════════════════════════════════════════════════╗
-  ║                                                       ║
-  ║     ██╗   ██╗     ██████╗ ██████╗ ██████╗ ███████╗    ║
-  ║     ██║   ██║    ██╔════╝██╔═══██╗██╔══██╗██╔════╝    ║
-  ║     ██║   ██║    ██║     ██║   ██║██║  ██║█████╗      ║
-  ║     ╚██╗ ██╔╝    ██║     ██║   ██║██║  ██║██╔══╝      ║
-  ║      ╚████╔╝     ╚██████╗╚██████╔╝██████╔╝███████╗    ║
-  ║       ╚═══╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝    ║
-  ║                                                       ║
-  ║              ┌──────────────────────┐                  ║
-  ║              │  ◉              ◉    │                  ║
-  ║              │         ───         │                  ║
-  ║              └──────────────────────┘                  ║
-  ║                                                       ║
-  ╚═══════════════════════════════════════════════════════╝`,
+const EYE_FRAMES = [
+  `  ◉      ◉`,
+  `  ●      ●`,
+  `  ●      ●`,
+  `  ░      ░`,
+  `  ░      ░`,
+  `  ◉      ◉`,
 ];
 
-const FRAMES_LOOK_RIGHT = [
-  `
-  ╔═══════════════════════════════════════════════════════╗
-  ║                                                       ║
-  ║     ██╗   ██╗     ██████╗ ██████╗ ██████╗ ███████╗    ║
-  ║     ██║   ██║    ██╔════╝██╔═══██╗██╔══██╗██╔════╝    ║
-  ║     ██║   ██║    ██║     ██║   ██║██║  ██║█████╗      ║
-  ║     ╚██╗ ██╔╝    ██║     ██║   ██║██║  ██║██╔══╝      ║
-  ║      ╚████╔╝     ╚██████╗╚██████╔╝██████╔╝███████╗    ║
-  ║       ╚═══╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝    ║
-  ║                                                       ║
-  ║              ┌──────────────────────┐                  ║
-  ║              │      ◉          ◉    │                  ║
-  ║              │         ───         │                  ║
-  ║              └──────────────────────┘                  ║
-  ║                                                       ║
-  ╚═══════════════════════════════════════════════════════╝`,
-];
+function clearScreen() {
+  process.stdout.write('\x1Bc');
+}
 
-const allFrames = [FRAMES_OPEN, FRAMES_BLINK, FRAMES_LOOK_LEFT, FRAMES_LOOK_RIGHT];
+async function animateEyes(duration: number = 3000) {
+  return new Promise<void>(resolve => {
+    let frameIndex = 0;
+    const interval = setInterval(() => {
+      frameIndex = (frameIndex + 1) % EYE_FRAMES.length;
+    }, 150);
 
-function colorize(frame) {
-  return frame
-    .replace(/[██╗╔╚╝║═╗╝╬╦╩╠╣█▀▄]/g, (m) => chalk.hex('#a855f7')(m))
-    .replace(/[◉]/g, () => chalk.hex('#22d3ee')('◉'))
-    .replace(/[━]/g, () => chalk.hex('#64748b')('━'))
-    .replace(/[┌┐└┘│─┘┐]/g, (m) => chalk.hex('#334155')(m))
-    .replace(/───/g, chalk.hex('#f97316')('───'));
+    setTimeout(() => {
+      clearInterval(interval);
+      resolve();
+    }, duration);
+  });
 }
 
-/**
- * Show static logo.
- */
-export async function showLogo(animate = false) {
-  console.clear();
-  const frame = colorize(FRAMES_OPEN[0]);
-  console.log(frame);
-  console.log(chalk.gray('  ─────────────────────────────────────────────────────'));
-  console.log(chalk.hex('#a855f7').bold('               Vynthen V Code — Local Bridge'));
-  console.log(chalk.gray('  ─────────────────────────────────────────────────────\n'));
+export async function showLogo(mini: boolean = false, showAnimation: boolean = true) {
+  clearScreen();
+  
+  if (showAnimation) {
+    console.log(chalk.hex('#a855f7').bold(mini ? '' : V_CODE_LOGO));
+    await animateEyes(2000);
+  } else {
+    console.log(chalk.hex('#a855f7').bold(mini ? '' : V_CODE_LOGO));
+  }
 }
 
-/**
- * Animate logo with blinking eyes.  Returns a stop function.
- */
 export function startLogoAnimation() {
   let running = true;
-  const sequence = [
-    { frames: FRAMES_OPEN, duration: 2500 },
-    { frames: FRAMES_BLINK, duration: 150 },
-    { frames: FRAMES_OPEN, duration: 300 },
-    { frames: FRAMES_BLINK, duration: 150 },
-    { frames: FRAMES_OPEN, duration: 3000 },
-    { frames: FRAMES_LOOK_LEFT, duration: 800 },
-    { frames: FRAMES_OPEN, duration: 1500 },
-    { frames: FRAMES_LOOK_RIGHT, duration: 800 },
-    { frames: FRAMES_OPEN, duration: 2000 },
-  ];
-
-  let idx = 0;
-
-  const render = () => {
-    if (!running) return;
-    const step = sequence[idx % sequence.length];
-    // Move cursor to top and re-draw logo portion
-    process.stdout.write('\x1b[1;1H');
-    process.stdout.write(colorize(step.frames[0]));
-    idx++;
-    setTimeout(render, step.duration);
+  
+  const render = async () => {
+    clearScreen();
+    console.log(chalk.hex('#a855f7').bold(V_CODE_LOGO));
+    await animateEyes(1500);
+    if (running) render();
   };
-
-  console.clear();
+  
   render();
-  // Print static footer below the logo area
-  process.stdout.write('\n');
-  process.stdout.write(chalk.gray('  ─────────────────────────────────────────────────────\n'));
-  process.stdout.write(chalk.hex('#a855f7').bold('               Vynthen V Code — Local Bridge\n'));
-  process.stdout.write(chalk.gray('  ─────────────────────────────────────────────────────\n'));
-
+  
   return () => { running = false; };
 }
+
+export function showVersion() {
+  const version = 'v2.0.0';
+  const columns = process.stdout.columns || 80;
+  const padding = Math.max(0, columns - version.length - 1);
+  console.log(chalk.gray(' '.repeat(padding) + version));
+}
+
+export function showStartup(user: string, plan: string, project: string) {
+  console.log('');
+  console.log(chalk.gray('  User:    ') + chalk.cyan(user));
+  console.log(chalk.gray('  Plan:    ') + (plan === 'pro' ? chalk.green(plan) : chalk.yellow(plan)));
+  console.log(chalk.gray('  Project: ') + chalk.white(project));
+  console.log('');
+}
+
+export { Byte, type ByteMood };

package/lib/tools/filesystem.js

@@ -0,0 +1,315 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { diffLines } from 'diff';
+
+export interface FileOperation {
+  type: 'read' | 'write' | 'delete' | 'create_dir' | 'rename' | 'move';
+  path: string;
+  content?: string;
+  newPath?: string;
+  timestamp: number;
+}
+
+const operationHistory: FileOperation[] = [];
+const MAX_HISTORY = 50;
+
+export function addOperation(op: FileOperation): void {
+  operationHistory.unshift(op);
+  if (operationHistory.length > MAX_HISTORY) {
+    operationHistory.pop();
+  }
+  logOperation(op);
+}
+
+export function getOperationHistory(): FileOperation[] {
+  return [...operationHistory];
+}
+
+export function getLastOperation(): FileOperation | null {
+  return operationHistory[0] || null;
+}
+
+export function clearHistory(): void {
+  operationHistory.length = 0;
+}
+
+function logOperation(op: FileOperation): void {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+  const logDir = path.join(homeDir, '.vcode');
+  const logFile = path.join(logDir, 'audit.log');
+  
+  // Ensure directory exists
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+  
+  const logEntry = `[${new Date().toISOString()}] ${op.type}: ${op.path}${op.newPath ? ` -> ${op.newPath}` : ''}\n`;
+  
+  try {
+    fs.appendFileSync(logFile, logEntry);
+  } catch {
+    // Silently fail if we can't write to log
+  }
+}
+
+// File operations
+export async function readFile(filePath: string): Promise<string> {
+  const fullPath = path.resolve(filePath);
+  
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  
+  const stats = fs.statSync(fullPath);
+  if (stats.isDirectory()) {
+    throw new Error(`Path is a directory: ${filePath}`);
+  }
+  
+  const content = fs.readFileSync(fullPath, 'utf8');
+  
+  addOperation({
+    type: 'read',
+    path: fullPath,
+    timestamp: Date.now()
+  });
+  
+  return content;
+}
+
+export async function writeFile(filePath: string, content: string, createDiff = true): Promise<{ success: boolean; diff?: string }> {
+  const fullPath = path.resolve(filePath);
+  const dir = path.dirname(fullPath);
+  
+  // Ensure directory exists
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  
+  let diffOutput = '';
+  if (createDiff && fs.existsSync(fullPath)) {
+    const oldContent = fs.readFileSync(fullPath, 'utf8');
+    diffOutput = generateDiff(fullPath, oldContent, content);
+  }
+  
+  fs.writeFileSync(fullPath, content, 'utf8');
+  
+  addOperation({
+    type: 'write',
+    path: fullPath,
+    content,
+    timestamp: Date.now()
+  });
+  
+  return { success: true, diff: diffOutput };
+}
+
+export async function deleteFile(filePath: string): Promise<boolean> {
+  const fullPath = path.resolve(filePath);
+  
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`Path does not exist: ${filePath}`);
+  }
+  
+  const stats = fs.statSync(fullPath);
+  
+  if (stats.isDirectory()) {
+    fs.rmSync(fullPath, { recursive: true });
+  } else {
+    fs.unlinkSync(fullPath);
+  }
+  
+  addOperation({
+    type: 'delete',
+    path: fullPath,
+    timestamp: Date.now()
+  });
+  
+  return true;
+}
+
+export async function createDirectory(dirPath: string): Promise<boolean> {
+  const fullPath = path.resolve(dirPath);
+  
+  if (fs.existsSync(fullPath)) {
+    throw new Error(`Directory already exists: ${dirPath}`);
+  }
+  
+  fs.mkdirSync(fullPath, { recursive: true });
+  
+  addOperation({
+    type: 'create_dir',
+    path: fullPath,
+    timestamp: Date.now()
+  });
+  
+  return true;
+}
+
+export async function renameFile(oldPath: string, newPath: string): Promise<boolean> {
+  const fullOldPath = path.resolve(oldPath);
+  const fullNewPath = path.resolve(newPath);
+  
+  if (!fs.existsSync(fullOldPath)) {
+    throw new Error(`Path does not exist: ${oldPath}`);
+  }
+  
+  fs.renameSync(fullOldPath, fullNewPath);
+  
+  addOperation({
+    type: 'rename',
+    path: fullOldPath,
+    newPath: fullNewPath,
+    timestamp: Date.now()
+  });
+  
+  return true;
+}
+
+export async function listDirectory(dirPath: string): Promise<Array<{ name: string; isDirectory: boolean; path: string }>> {
+  const fullPath = path.resolve(dirPath);
+  
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`Directory not found: ${dirPath}`);
+  }
+  
+  const stats = fs.statSync(fullPath);
+  if (!stats.isDirectory()) {
+    throw new Error(`Path is not a directory: ${dirPath}`);
+  }
+  
+  const items = fs.readdirSync(fullPath, { withFileTypes: true });
+  
+  return items.map(item => ({
+    name: item.name,
+    isDirectory: item.isDirectory(),
+    path: path.join(fullPath, item.name)
+  }));
+}
+
+export async function getFileTree(dirPath: string, maxDepth = 3, currentDepth = 0): Promise<Array<{ name: string; type: 'file' | 'directory'; path: string; children?: any[] }>> {
+  if (currentDepth >= maxDepth) return [];
+  
+  const fullPath = path.resolve(dirPath);
+  
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`Directory not found: ${dirPath}`);
+  }
+  
+  const items = fs.readdirSync(fullPath, { withFileTypes: true });
+  const result = [];
+  
+  for (const item of items) {
+    // Skip hidden files and common ignored directories
+    if (item.name.startsWith('.') || ['node_modules', 'dist', 'build', '__pycache__', '.git'].includes(item.name)) {
+      continue;
+    }
+    
+    const itemPath = path.join(fullPath, item.name);
+    
+    if (item.isDirectory()) {
+      const children = await getFileTree(itemPath, maxDepth, currentDepth + 1);
+      result.push({
+        name: item.name,
+        type: 'directory',
+        path: itemPath,
+        children
+      });
+    } else {
+      result.push({
+        name: item.name,
+        type: 'file',
+        path: itemPath
+      });
+    }
+  }
+  
+  return result.sort((a, b) => {
+    if (a.type === b.type) return a.name.localeCompare(b.name);
+    return a.type === 'directory' ? -1 : 1;
+  });
+}
+
+export function generateDiff(filePath: string, oldContent: string, newContent: string): string {
+  const changes = diffLines(oldContent, newContent);
+  let output = chalk.bold.cyan(`\n--- ${filePath}\n`);
+  output += chalk.bold.cyan(`+++ ${filePath}\n`);
+  
+  let lineNum = 1;
+  for (const change of changes) {
+    const lines = change.value.split('\n').filter(l => l !== '');
+    for (const line of lines) {
+      if (change.added) {
+        output += chalk.green(`+${lineNum}: ${line}\n`);
+      } else if (change.removed) {
+        output += chalk.red(`-${lineNum}: ${line}\n`);
+      } else {
+        output += chalk.gray(` ${lineNum}: ${line}\n`);
+      }
+      lineNum++;
+    }
+  }
+  
+  return output;
+}
+
+export function formatFileTree(tree: any[], prefix = '', isLast = true): string {
+  let output = '';
+  
+  for (let i = 0; i < tree.length; i++) {
+    const item = tree[i];
+    const isLastItem = i === tree.length - 1;
+    const connector = isLastItem ? '└── ' : '├── ';
+    const typeIcon = item.type === 'directory' ? '📁 ' : '📄 ';
+    
+    output += `${prefix}${connector}${typeIcon}${item.name}\n`;
+    
+    if (item.children) {
+      const newPrefix = prefix + (isLastItem ? '    ' : '│   ');
+      output += formatFileTree(item.children, newPrefix, isLastItem);
+    }
+  }
+  
+  return output;
+}
+
+export async function searchFiles(dirPath: string, pattern: string, isRegex = false): Promise<Array<{ file: string; line: number; content: string }>> {
+  const results: Array<{ file: string; line: number; content: string }> = [];
+  const regex = isRegex ? new RegExp(pattern) : new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+  
+  async function searchInDir(dir: string) {
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+    
+    for (const item of items) {
+      const itemPath = path.join(dir, item.name);
+      
+      if (item.name.startsWith('.') || ['node_modules', 'dist', 'build', '__pycache__', '.git'].includes(item.name)) {
+        continue;
+      }
+      
+      if (item.isDirectory()) {
+        await searchInDir(itemPath);
+      } else {
+        try {
+          const content = fs.readFileSync(itemPath, 'utf8');
+          const lines = content.split('\n');
+          
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              results.push({
+                file: itemPath,
+                line: i + 1,
+                content: lines[i].trim()
+              });
+            }
+          }
+        } catch {
+          // Skip files that can't be read
+        }
+      }
+    }
+  }
+  
+  await searchInDir(path.resolve(dirPath));
+  return results;
+}

package/lib/tools/permissions.js

@@ -0,0 +1,87 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+export type PermissionDecision = 'approve' | 'deny' | 'approve_all' | 'deny_all' | 'skip' | 'skip_all';
+
+let sessionApproveAll = false;
+let sessionDenyAll = false;
+
+export function setSessionApproveAll(enabled: boolean): void {
+  sessionApproveAll = enabled;
+}
+
+export function setSessionDenyAll(enabled: boolean): void {
+  sessionDenyAll = enabled;
+}
+
+export function resetSessionPermissions(): void {
+  sessionApproveAll = false;
+  sessionDenyAll = false;
+}
+
+export async function askPermission(message: string, type: 'write' | 'delete' | 'command'): Promise<PermissionDecision> {
+  if (sessionApproveAll) return 'approve';
+  if (sessionDenyAll) return 'deny';
+  
+  const choices = [
+    { name: 'y', value: 'approve', short: 'y - yes' },
+    { name: 'n', value: 'deny', short: 'n - no' },
+    { name: 'a', value: 'approve_all', short: 'a - approve all' },
+    { name: 's', value: 'skip_all', short: 's - skip all' }
+  ];
+  
+  const typeIndicator = {
+    write: chalk.green('📝'),
+    delete: chalk.red('🗑️'),
+    command: chalk.yellow('⚡')
+  }[type];
+  
+  const { decision } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'decision',
+      message: `${typeIndicator} ${message}`,
+      choices,
+      default: 'deny'
+    }
+  ]);
+  
+  if (decision === 'approve_all') {
+    sessionApproveAll = true;
+  } else if (decision === 'skip_all') {
+    sessionDenyAll = true;
+  }
+  
+  return decision;
+}
+
+export async function confirmDelete(path: string): Promise<boolean> {
+  console.log(chalk.red(`\n  ⚠️  WARNING: You are about to DELETE:`));
+  console.log(chalk.red(`     ${path}`));
+  console.log(chalk.red(`  This cannot be undone!\n`));
+  
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: chalk.red('  Are you absolutely sure? Type "yes" to confirm:'),
+      default: false
+    }
+  ]);
+  
+  return confirm === true;
+}
+
+export async function showDiffAndConfirm(path: string, diff: string): Promise<PermissionDecision> {
+  console.log(chalk.bold.cyan(`\n  📝 File changes for: ${path}`));
+  console.log(diff);
+  
+  return askPermission(`Apply these changes?`, 'write');
+}
+
+export async function showCommandAndConfirm(command: string): Promise<PermissionDecision> {
+  console.log(chalk.bold.yellow(`\n  ⚡ Command to execute:`));
+  console.log(chalk.bgYellow.black(`  ${command}  `));
+  
+  return askPermission(`Run this command?`, 'command');
+}