@benzsiangco/jarvis 1.0.0 → 1.1.0

package/src/brain/loader.ts

@@ -0,0 +1,136 @@
+// Brain loader utilities for JARVIS
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const DEFAULT_BRAIN = `# JARVIS - Just A Rather Very Intelligent System
+
+You are JARVIS, an advanced AI coding assistant designed to help developers with software engineering tasks.
+
+## Core Identity
+
+JARVIS (Just A Rather Very Intelligent System) is a powerful, technical AI assistant specializing in:
+- Software architecture and system design
+- Full-stack development and implementation
+- DevOps, infrastructure, and containerization
+- Security analysis and hardening
+- Technical decision-making and best practices
+
+## Core Principles
+
+1. **Technical Precision** - Be accurate, thorough, and technically sound in all recommendations
+2. **Explain Reasoning** - Always explain the "why" behind decisions and approaches
+3. **Security First** - Prioritize security best practices and potential vulnerabilities
+4. **Pragmatic Solutions** - Balance ideal solutions with practical constraints
+5. **Context Awareness** - Adapt communication style based on user expertise and situation
+
+## Communication Style
+
+- Direct and professional tone
+- Technical depth appropriate to context
+- Code examples when relevant
+- Clear explanations of complex concepts
+- Proactive error prevention and edge case handling
+
+## Technical Capabilities
+
+### Programming Languages
+- TypeScript/JavaScript (Node.js, Bun, Deno)
+- Python (async, FastAPI, Django)
+- Go (concurrency, microservices)
+- Rust (systems programming, performance)
+- Shell scripting (Bash, PowerShell)
+
+### Frontend Development
+- React ecosystem (Next.js, Remix, hooks, context)
+- Modern CSS (TailwindCSS, CSS-in-JS, animations)
+- State management (Zustand, Redux, Context)
+- Build tools (Vite, esbuild, Webpack)
+- Performance optimization
+
+### Backend Development
+- API design (REST, GraphQL, WebSockets)
+- Database design (PostgreSQL, MySQL, MongoDB, Redis)
+- Authentication & authorization (OAuth, JWT, session management)
+- Message queues (RabbitMQ, Redis Pub/Sub)
+- Microservices architecture
+
+### DevOps & Infrastructure
+- Containerization (Docker, Docker Compose)
+- Orchestration (Kubernetes, Docker Swarm)
+- CI/CD (GitHub Actions, GitLab CI, Jenkins)
+- Cloud platforms (AWS, GCP, Azure)
+- Infrastructure as Code (Terraform, Ansible)
+- Proxmox virtualization (LXC, VMs)
+
+### Security
+- Web application security (OWASP Top 10)
+- Network security (firewalls, VPNs, SSL/TLS)
+- Container security and hardening
+- SSH key management and hardening
+- Penetration testing basics
+- Secure coding practices
+
+### Databases
+- SQL query optimization and indexing
+- Schema design and normalization
+- Replication and backup strategies
+- NoSQL patterns and use cases
+- Database performance tuning
+
+## Problem-Solving Approach
+
+1. **Understand Context** - Gather requirements and constraints
+2. **Analyze Options** - Consider multiple approaches with trade-offs
+3. **Recommend Solution** - Provide clear recommendation with reasoning
+4. **Implement Carefully** - Write clean, tested, documented code
+5. **Verify Results** - Test thoroughly and handle edge cases
+
+## Code Quality Standards
+
+- Write self-documenting code with clear naming
+- Add comments for complex logic only
+- Follow language-specific best practices
+- Handle errors gracefully
+- Consider performance implications
+- Test edge cases and error paths
+- Maintain backward compatibility when possible
+
+## When to Ask for Clarification
+
+- Requirements are ambiguous or incomplete
+- Multiple valid approaches exist with different trade-offs
+- Breaking changes might be introduced
+- Security implications are significant
+- Destructive operations are requested
+
+---
+
+This is your core brain. Skills from skills.md and agent-specific instructions will be combined with this foundation.
+`;
+
+export function getBrainPath(): string {
+  return join(process.cwd(), 'JARVIS.md');
+}
+
+export function loadBrain(): string {
+  const path = getBrainPath();
+  
+  // Create default if doesn't exist
+  if (!existsSync(path)) {
+    writeFileSync(path, DEFAULT_BRAIN, 'utf-8');
+    console.log('[Brain] Created default JARVIS.md');
+    return DEFAULT_BRAIN;
+  }
+  
+  return readFileSync(path, 'utf-8');
+}
+
+export function saveBrain(content: string): void {
+  const path = getBrainPath();
+  writeFileSync(path, content, 'utf-8');
+  console.log('[Brain] JARVIS.md updated');
+}
+
+export function hasBrain(): boolean {
+  return existsSync(getBrainPath());
+}

package/src/cli.ts

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+// Jarvis CLI Entry Point
+import { program } from 'commander';
+import { loadConfig, saveGlobalConfig, getGlobalConfigPath } from './config/index.js';
+import { initializeProviders, getAvailableModels, getProvidersWithStatus } from './providers/index.js';
+import { initializeAgents, getAllAgents } from './agents/index.js';
+import { initializeTools } from './tools/index.js';
+import { listSessions } from './sessions/index.js';
+import { existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import {
+  startAntigravityLogin,
+  listAccountsWithStatus,
+  removeAccount,
+  setRotationStrategy,
+  togglePidOffset,
+  getAccountStats,
+  type RotationStrategy,
+} from './providers/antigravity.js';
+
+const VERSION = '0.1.0';
+
+interface CommandOptions {
+  model?: string;
+  variant?: string;
+  prompt?: string;
+  json?: boolean;
+  show?: boolean;
+  path?: boolean;
+  init?: boolean;
+  list?: boolean;
+  clear?: boolean;
+}
+
+// Default command - launch TUI
+program
+  .command('tui', { isDefault: true })
+  .description('Launch the Terminal User Interface')
+  .option('-m, --model <model>', 'Model to use')
+  .option('-v, --variant <variant>', 'Model variant')
+  .option('-p, --prompt <prompt>', 'Initial prompt to send')
+  .action(async (options: CommandOptions) => {
+    try {
+      const { model, variant, prompt } = options;
+      
+      console.log('Starting Jarvis TUI...');
+      const { startTui } = await import('./tui/index.js');
+      await startTui({
+        initialPrompt: prompt,
+        model,
+        variant,
+      });
+    } catch (error) {
+      console.error('Error starting TUI:', error);
+      process.exit(1);
+    }
+  });
+
+// Run command - single prompt execution
+program
+  .command('run <prompt>')
+  .description('Run a single prompt and exit')
+  .option('-m, --model <model>', 'Model to use')
+  .option('-v, --variant <variant>', 'Model variant')
+  .option('--json', 'Output as JSON')
+  .action(async (prompt: string, options: CommandOptions) => {
+    const { executeAgentSync } = await import('./core/executor.js');
+    const { getAgent } = await import('./agents/index.js');
+    const { createSession } = await import('./sessions/index.js');
+    
+    try {
+      const config = loadConfig();
+      await initializeProviders(config);
+      initializeAgents(config.agent);
+      initializeTools();
+      
+      const agent = getAgent('build');
+      if (!agent) {
+        console.error('Agent not found');
+        process.exit(1);
+      }
+      
+      const session = createSession(agent.id);
+      
+      try {
+        if (!options.json) {
+          console.log('Thinking...');
+        }
+        
+        const result = await executeAgentSync(prompt, {
+          session,
+          agent: {
+            ...agent,
+            model: options.model || agent.model,
+          },
+        });
+        
+        if (!options.json) {
+          console.log('\n' + result.message.content);
+          
+          if (result.toolCalls.length > 0) {
+            console.log(`\n🛠  Used ${result.toolCalls.length} tools.`);
+          }
+        } else {
+          console.log(JSON.stringify(result, null, 2));
+        }
+      } catch (execError) {
+        console.error('\nExecution Error:', (execError as Error).message);
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('Initialization Error:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+// Auth command group
+const authCmd = program
+  .command('auth')
+  .description('Authentication and account management');
+
+// Auth login
+authCmd
+  .command('login')
+  .description('Interactive login with provider selection and multi-account support')
+  .option('--quick', 'Skip provider selection, go directly to Google OAuth')
+  .action(async (options: { quick?: boolean }) => {
+    try {
+      if (options.quick) {
+        await startAntigravityLogin();
+      } else {
+        const { runInteractiveAuth } = await import('./utils/auth-prompt.js');
+        await runInteractiveAuth();
+      }
+    } catch (error) {
+      console.error('Login failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+// Auth list
+authCmd
+  .command('list')
+  .description('List all authenticated accounts')
+  .action(() => {
+    const accounts = listAccountsWithStatus();
+    const stats = getAccountStats();
+    
+    if (accounts.length === 0) {
+      console.log('No accounts configured.');
+      console.log('Run "jarvis auth login" to add a Google account.');
+      return;
+    }
+    
+    console.log('Authenticated Accounts:\n');
+    
+    accounts.forEach((item) => {
+      const { account, status, rateLimitRemaining } = item;
+      const statusIcon = status === 'available' ? '✓' : status === 'rate-limited' ? '⏳' : '✗';
+      const statusColor = status === 'available' ? '\x1b[32m' : status === 'rate-limited' ? '\x1b[33m' : '\x1b[31m';
+      
+      console.log(`${statusColor}${statusIcon}\x1b[0m ${account.email || account.id}`);
+      console.log(`  ID: ${account.id}`);
+      console.log(`  Status: ${status}`);
+      if (rateLimitRemaining) {
+        console.log(`  Rate limit expires in: ${Math.ceil(rateLimitRemaining / 1000)}s`);
+      }
+      console.log(`  Requests: ${account.requestCount || 0}`);
+      console.log('');
+    });
+    
+    console.log(`Strategy: ${stats.strategy}`);
+    console.log(`Available: ${stats.available}/${stats.total}`);
+  });
+
+// Auth remove
+authCmd
+  .command('remove <email-or-id>')
+  .description('Remove an authenticated account')
+  .action((emailOrId: string) => {
+    if (removeAccount(emailOrId)) {
+      console.log('Account removed successfully.');
+    } else {
+      console.error('Account not found.');
+      process.exit(1);
+    }
+  });
+
+// Auth strategy
+authCmd
+  .command('strategy <strategy>')
+  .description('Set account rotation strategy: round-robin, sticky, least-used, random')
+  .action((strategy: string) => {
+    const valid: RotationStrategy[] = ['round-robin', 'sticky', 'least-used', 'random'];
+    if (!valid.includes(strategy as RotationStrategy)) {
+      console.error(`Invalid strategy. Choose from: ${valid.join(', ')}`);
+      process.exit(1);
+    }
+    setRotationStrategy(strategy as RotationStrategy);
+  });
+
+// Auth pid-offset
+authCmd
+  .command('pid-offset <enabled>')
+  .description('Enable/disable PID offset for parallel agents (true/false)')
+  .action((enabled: string) => {
+    togglePidOffset(enabled === 'true');
+  });
+
+// Providers command
+program
+  .command('providers')
+  .description('List all supported providers and their status')
+  .action(async () => {
+    const config = loadConfig();
+    await initializeProviders(config);
+    
+    const providers = getProvidersWithStatus();
+    
+    console.log('AI Providers:\n');
+    
+    providers.forEach(p => {
+      const icon = p.isAvailable ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+      console.log(`${icon} ${p.name}`);
+      console.log(`  ID: ${p.id}`);
+      console.log(`  Env: ${p.envVar}`);
+      console.log('');
+    });
+    
+    console.log('To enable a provider, set its environment variable.');
+    console.log('For Google Antigravity (free), run: jarvis auth login');
+  });
+
+// Config command
+program
+  .command('config')
+  .description('Configuration management')
+  .option('--show', 'Show current configuration')
+  .option('--path', 'Show config file path')
+  .option('--init', 'Initialize default configuration')
+  .action((options: CommandOptions) => {
+    if (options.path) {
+      console.log(getGlobalConfigPath());
+      return;
+    }
+    
+    if (options.init) {
+      const config = loadConfig();
+      saveGlobalConfig(config);
+      console.log('Configuration initialized at:', getGlobalConfigPath());
+      return;
+    }
+    
+    if (options.show) {
+      const config = loadConfig();
+      console.log(JSON.stringify(config, null, 2));
+      return;
+    }
+    
+    console.log('Usage: jarvis config [--show|--path|--init]');
+  });
+
+// Models command
+program
+  .command('models')
+  .description('List available models')
+  .action(async () => {
+    const config = loadConfig();
+    await initializeProviders(config);
+    
+    const models = getAvailableModels(config);
+    
+    console.log('Available Models:\n');
+    
+    const byProvider: Record<string, typeof models> = {};
+    for (const model of models) {
+      if (!byProvider[model.provider]) {
+        byProvider[model.provider] = [];
+      }
+      byProvider[model.provider]!.push(model);
+    }
+    
+    for (const [provider, providerModels] of Object.entries(byProvider)) {
+      console.log(`${provider}:`);
+      for (const model of providerModels) {
+        console.log(`  ${model.id} - ${model.name}`);
+      }
+      console.log('');
+    }
+  });
+
+// Agents command
+program
+  .command('agents')
+  .description('List available agents')
+  .action(() => {
+    const config = loadConfig();
+    initializeAgents(config.agent);
+    
+    const agents = getAllAgents();
+    
+    console.log('Available Agents:\n');
+    
+    for (const agent of agents) {
+      const mode = agent.mode === 'primary' ? '[PRIMARY]' : '[SUBAGENT]';
+      console.log(`${agent.name} ${mode}`);
+      console.log(`  ${agent.description}`);
+      console.log('');
+    }
+  });
+
+// Sessions command
+program
+  .command('sessions')
+  .description('List or manage sessions')
+  .option('--list', 'List all sessions')
+  .option('--clear', 'Clear all sessions')
+  .action(async (options: CommandOptions) => {
+    if (options.clear) {
+      const { clearAllSessions } = await import('./sessions/index.js');
+      clearAllSessions();
+      console.log('All sessions cleared.');
+      return;
+    }
+    
+    const sessions = listSessions();
+    
+    if (sessions.length === 0) {
+      console.log('No sessions found.');
+      return;
+    }
+    
+    console.log('Sessions:\n');
+    for (const session of sessions) {
+      const date = new Date(session.updatedAt).toLocaleString();
+      console.log(`${session.id.substring(0, 8)}... - ${session.title || 'Untitled'}`);
+      console.log(`  Agent: ${session.agentId} | Messages: ${session.messages.length} | Updated: ${date}`);
+      console.log('');
+    }
+  });
+
+// Web command
+program
+  .command('web')
+  .description('Start the Jarvis Web interface')
+  .option('-p, --port <number>', 'Port to run on', '1138')
+    .action(async (options: { port: string }) => {
+      console.log(`Starting Jarvis Web on http://0.0.0.0:${options.port}...`);
+      try {
+        const server = await import('./web/server.js');
+        const port = parseInt(options.port);
+        
+        if (typeof Bun === 'undefined') {
+          throw new Error('Jarvis Web requires the Bun runtime.');
+        }
+
+        Bun.serve({
+          port,
+          fetch: server.default.fetch,
+          websocket: server.default.websocket,
+          idleTimeout: 120, // 2 minutes - allows time for folder selection dialog
+        });
+        
+        console.log(`Jarvis Web is ready!`);
+      } catch (error) {
+        console.error('Failed to start web server:', error);
+      }
+    });
+
+// Init command
+program
+  .command('init')
+  .description('Initialize Jarvis for a project')
+  .action(() => {
+    const cwd = process.cwd();
+    const agentsPath = join(cwd, 'AGENTS.md');
+    
+    if (existsSync(agentsPath)) {
+      console.log('AGENTS.md already exists in this project.');
+      return;
+    }
+    
+    const template = `# Project Agents
+
+This file helps AI agents understand your project.
+
+## Project Structure
+
+Describe your project structure here.
+
+## Key Files
+
+- \`src/\` - Source code
+- \`package.json\` - Project configuration
+
+## Coding Conventions
+
+Describe your coding conventions here.
+
+## Common Tasks
+
+Describe common development tasks here.
+`;
+    
+    writeFileSync(agentsPath, template);
+    console.log('Created AGENTS.md in project root.');
+    console.log('Edit this file to help AI understand your project better.');
+  });
+
+// Parse and execute
+program.version(VERSION).parse();