vcode-cli 1.0.4 → 2.0.0

package/lib/tools/shell.js

@@ -0,0 +1,150 @@
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+
+export interface CommandResult {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  command: string;
+}
+
+const DANGEROUS_COMMANDS = ['rm -rf', 'del /f /s /q', 'format', 'dd if=', 'mkfs', ':(){:|:&};:'];
+
+export async function runCommand(command: string, cwd?: string, timeout = 60000): Promise<CommandResult> {
+  const isWindows = process.platform === 'win32';
+  const shell = isWindows ? 'cmd.exe' : '/bin/bash';
+  const shellArgs = isWindows ? ['/c', command] : ['-c', command];
+  
+  // Security check
+  for (const dangerous of DANGEROUS_COMMANDS) {
+    if (command.toLowerCase().includes(dangerous.toLowerCase())) {
+      return {
+        success: false,
+        stdout: '',
+        stderr: `Command blocked: contains potentially dangerous operation "${dangerous}"`,
+        exitCode: 1,
+        command
+      };
+    }
+  }
+  
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    
+    const child = spawn(shell, shellArgs, {
+      cwd: cwd || process.cwd(),
+      env: { ...process.env, FORCE_COLOR: '1' }
+    });
+    
+    const timeoutId = setTimeout(() => {
+      child.kill();
+      resolve({
+        success: false,
+        stdout,
+        stderr: 'Command timed out',
+        exitCode: 124,
+        command
+      });
+    }, timeout);
+    
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+    
+    child.on('close', (code) => {
+      clearTimeout(timeoutId);
+      resolve({
+        success: code === 0,
+        stdout,
+        stderr,
+        exitCode: code || 0,
+        command
+      });
+    });
+    
+    child.on('error', (err) => {
+      clearTimeout(timeoutId);
+      resolve({
+        success: false,
+        stdout,
+        stderr: err.message,
+        exitCode: 1,
+        command
+      });
+    });
+  });
+}
+
+export function formatCommandOutput(result: CommandResult): string {
+  let output = '';
+  
+  if (result.stdout) {
+    output += chalk.white(result.stdout);
+  }
+  
+  if (result.stderr) {
+    output += chalk.red(result.stderr);
+  }
+  
+  return output;
+}
+
+export async function runGitCommand(args: string[], cwd?: string): Promise<CommandResult> {
+  return runCommand(`git ${args.join(' ')}`, cwd);
+}
+
+export async function gitStatus(cwd?: string): Promise<{ modified: string[]; untracked: string[]; staged: string[] }> {
+  const result = await runGitCommand(['status', '--porcelain'], cwd);
+  
+  if (!result.success) {
+    throw new Error(result.stderr);
+  }
+  
+  const modified: string[] = [];
+  const untracked: string[] = [];
+  const staged: string[] = [];
+  
+  for (const line of result.stdout.split('\n').filter(l => l.trim())) {
+    const status = line.substring(0, 2);
+    const file = line.substring(3);
+    
+    if (status.includes('M') || status.includes('D')) {
+      modified.push(file);
+    }
+    if (status.includes('??')) {
+      untracked.push(file);
+    }
+    if (status.startsWith('M') || status.startsWith('A')) {
+      staged.push(file);
+    }
+  }
+  
+  return { modified, untracked, staged };
+}
+
+export async function gitDiff(file?: string, cwd?: string): Promise<string> {
+  const args = file ? ['diff', file] : ['diff'];
+  const result = await runGitCommand(args, cwd);
+  return result.stdout || result.stderr;
+}
+
+export async function gitCommit(message: string, cwd?: string): Promise<boolean> {
+  const result = await runGitCommand(['commit', '-m', message], cwd);
+  return result.success;
+}
+
+export async function gitPush(cwd?: string): Promise<boolean> {
+  const result = await runGitCommand(['push'], cwd);
+  return result.success;
+}
+
+export async function gitPull(cwd?: string): Promise<boolean> {
+  const result = await runGitCommand(['pull'], cwd);
+  return result.success;
+}

package/lib/ui/byte.js

@@ -0,0 +1,178 @@
+import chalk from 'chalk';
+
+export type ByteMood = 'idle' | 'thinking' | 'working' | 'success' | 'error' | 'waiting' | 'celebrating';
+
+const BYTE_ART = {
+  idle: `
+      /\\_____/\\
+     /  o   o  \\
+    ( ==  ^  == )
+     )         (
+    (           )
+   ( (  )   (  ) )
+  (__(__)___(__)__)
+  `,
+  
+  thinking: `
+      /\\_____/\\
+     /  ?   ?  \\
+    ( ==  O  == )
+     )         (
+    (     ?     )
+   ( (  )   (  ) )
+  (__(__)___(__)__)
+     |     |    
+    _|     |_
+  `,
+  
+  working: `
+      /\\_____/\\
+     /  o   o  \\
+    ( ==  ^  == )
+     )  /+\\  (
+    (    |    )
+   ( (  )   (  ) )
+  (__(__)___(__)__)
+   _||_   _||_
+  `,
+  
+  success: `
+      /\\_____/\\
+     /  ^   ^  \\
+    ( ==  ^  == )
+     )    ^    (
+    (   \\o/   )
+   ( (  )   (  ) )
+  (__(__)___(__)__)
+      \\o/ \\o/
+  `,
+  
+  error: `
+      /\\_____/\\
+     /  x   x  \\
+    ( ==  ^  == )
+     )   ___   (
+    (    |_|    )
+   ( (  )   (  ) )
+  (__(__)___(__)__)
+      _____ 
+     |     |
+     |_____|
+  `,
+  
+  waiting: `
+      /\\_____/\\
+     /  o   o  \\
+    ( ==  ^  == )
+     )    ~    (
+    (    |    )
+   ( (  )   (  ) )
+  (__(__)___(__)__)
+      ---  --->>>
+  `,
+  
+  celebrating: `
+      /\\_____/\\
+     /  ^   ^  \\
+    ( ==  ^  == )
+     )  \\o/   (
+    (   ( )   )
+   ( (  )   (  ) )
+  (__(__)___(__)__)
+    \\o/   \\o/
+   `
+};
+
+const MESSAGES = {
+  idle: ['ready when you are~', 'waiting for your command~', 'what shall we build?'],
+  thinking: ['hmm let me think...', 'processing...', 'give me a moment~'],
+  working: ['on it~', 'working on it...', 'type type type~'],
+  success: ['done! purr~', 'all done!', '任务完成!'],
+  error: ['uh oh...', 'oopsie~', 'that didn\'t work~'],
+  waiting: ['you sure about this?', 'waiting for your approval~', 'need your okay~'],
+  celebrating: ['we did it!', 'purrfect!', 'amazing work!']
+};
+
+let currentMood: ByteMood = 'idle';
+let companionEnabled = true;
+let animationInterval: NodeJS.Timeout | null = null;
+
+export function setCompanionEnabled(enabled: boolean): void {
+  companionEnabled = enabled;
+}
+
+export function isCompanionEnabled(): boolean {
+  return companionEnabled;
+}
+
+export function showByte(mood: ByteMood, customMessage?: string): void {
+  if (!companionEnabled) return;
+  
+  currentMood = mood;
+  const art = BYTE_ART[mood];
+  const messages = MESSAGES[mood];
+  const message = customMessage || messages[Math.floor(Math.random() * messages.length)];
+  
+  // Clear previous animation
+  if (animationInterval) {
+    clearInterval(animationInterval);
+    animationInterval = null;
+  }
+  
+  // For working mood, animate
+  if (mood === 'working') {
+    let frame = 0;
+    const frames = ['|', '/', '-', '\\'];
+    animationInterval = setInterval(() => {
+      const frameArt = BYTE_ART.working.replace(/\|/g, frames[frame % 4]);
+      console.clear();
+      console.log(chalk.hex('#a855f7')(frameArt));
+      console.log(chalk.gray(`  ${message}`));
+      frame++;
+    }, 100);
+  } else {
+    console.clear();
+    console.log(chalk.hex('#a855f7')(art));
+    console.log(chalk.gray(`  ${message}`));
+  }
+}
+
+export function clearByte(): void {
+  if (animationInterval) {
+    clearInterval(animationInterval);
+    animationInterval = null;
+  }
+}
+
+export function getByteMessage(mood: ByteMood): string {
+  const messages = MESSAGES[mood];
+  return messages[Math.floor(Math.random() * messages.length)];
+}
+
+export function showByteIdle(): void {
+  showByte('idle');
+}
+
+export function showByteThinking(): void {
+  showByte('thinking');
+}
+
+export function showByteWorking(): void {
+  showByte('working');
+}
+
+export function showByteSuccess(): void {
+  showByte('success');
+}
+
+export function showByteError(): void {
+  showByte('error');
+}
+
+export function showByteWaiting(message?: string): void {
+  showByte('waiting', message);
+}
+
+export function showByteCelebrating(): void {
+  showByte('celebrating');
+}

package/lib/ui/logo.js

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+import { showByteIdle } from './byte.js';
+
+const LOGO = `
+ ██████╗ ██╗██████╗ ███████╗██╗     ██╗███╗   ██╗███████╗
+██╔═══██╗██║██╔══██╗██╔════╝██║     ██║████╗  ██║██╔════╝
+██║   ██║██║██████╔╝█████╗  ██║     ██║██╔██╗ ██║█████╗  
+██║   ██║██║██╔══██╗██╔══╝  ██║     ██║██║╚██╗██║██╔══╝  
+╚██████╔╝██║██║  ██║███████╗███████╗██║██║ ╚████║███████╗
+ ╚═════╝ ╚═╝╚═╝  ╚═╝╚══════╝╚══════╝╚═╝╚═╝  ╚═══╝╚══════╝
+
+                 ██████╗ ███████╗███████╗██╗     ██╗███╗   ██╗
+                 ██╔══██╗██╔════╝██╔════╝██║     ██║████╗  ██║
+                 ██║  ██║█████╗  █████╗  ██║     ██║██╔██╗ ██║
+                 ██║  ██║██╔══╝  ██╔══╝  ██║     ██║██║╚██╗██║
+                 ██████╔╝███████╗███████╗███████╗██║██║ ╚████║
+                 ╚═════╝ ╚══════╝╚══════╝╚══════╝╚═╝╚═╝  ╚═══╝
+`;
+
+let blinkInterval: NodeJS.Timeout | null = null;
+
+export function showLogo(): void {
+  console.clear();
+  
+  const blink = () => {
+    console.clear();
+    const eyeFrame = Math.floor(Date.now() / 500) % 2;
+    const logo = eyeFrame === 0 ? LOGO.replace(/O/g, '●').replace(/o/g, '●') : LOGO;
+    console.log(chalk.hex('#a855f7').bold(logo));
+  };
+  
+  blinkInterval = setInterval(blink, 500);
+  
+  // Stop after initial animation
+  setTimeout(() => {
+    if (blinkInterval) clearInterval(blinkInterval);
+    console.clear();
+    console.log(chalk.hex('#a855f7').bold(LOGO));
+    showByteIdle();
+  }, 3000);
+}
+
+export function showLogoOnce(): void {
+  console.clear();
+  console.log(chalk.hex('#a855f7').bold(LOGO));
+}
+
+export function stopAnimation(): void {
+  if (blinkInterval) {
+    clearInterval(blinkInterval);
+    blinkInterval = null;
+  }
+}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "vcode-cli",
-  "version": "1.0.4",
+  "version": "2.0.0",
   "type": "module",
-  "description": "Connect your local machine to Vynthen V Code — a powerful AI code agent with full system control, secure keychain auth, and human-in-the-loop permissions.",
+  "description": "V Code — Terminal AI Coding Agent powered by Vynthen. Autonomous file editing, terminal commands, and smart context management.",
   "main": "bin/vcode.js",
   "bin": {
     "vcode": "bin/vcode.js"
   },
   "scripts": {
-    "start": "node bin/vcode.js start",
-    "serve": "node lib/server.js",
+    "start": "node bin/vcode.js",
+    "help": "node bin/vcode.js help",
     "test": "echo \"No tests yet\" && exit 0"
   },
   "keywords": [
@@ -19,10 +19,11 @@
     "code-agent",
     "cli",
     "terminal",
-    "developer-tools"
+    "developer-tools",
+    "coding-assistant"
   ],
-  "author": "Vynthen <hello@vynthen.com>",
-  "license": "MIT",
+  "author": "Tibebe Solomon <hello@vynthen.com>",
+  "license": "PROPRIETARY",
   "repository": {
     "type": "git",
     "url": "https://gitlab.com/TibebeSolomon/vcode-cli.git"
@@ -38,19 +39,15 @@
   ],
   "dependencies": {
     "chalk": "^5.3.0",
-    "clipboardy": "^4.0.0",
     "commander": "^12.1.0",
+    "diff": "^5.2.0",
     "inquirer": "^9.3.0",
-    "keytar": "^7.9.0",
-    "open": "^10.1.0",
-    "ora": "^8.0.1",
-    "screenshot-desktop": "^1.15.0",
-    "ws": "^8.18.0"
+    "keytar": "^7.9.0"
   },
   "files": [
     "bin/",
     "lib/",
-    "README.md",
-    "LICENSE"
+    "LICENSE",
+    "README.md"
   ]
-}
+}