shiroai 1.0.0 → 2.0.0

package/README.md

@@ -1,35 +1,35 @@
-# ✦ LeonAI CLI
+# ✦ ShiroAI CLI
 
 AI coding agent for your terminal. Create, edit, debug, and deploy — all from the command line.
 
 ## Install
 
 ```bash
-npm install -g leonai-cli
+npm install -g shiroai
 ```
 
 ## Setup
 
 ```bash
-leonai login YOUR_API_KEY
+shiroai login YOUR_API_KEY
 ```
 
-Get your API key at [leonai.dev](https://leonai.dev)
+Get your API key at [shiroai.dev](https://shiroai.dev)
 
 ## Usage
 
 ```bash
-leonai
+shiroai
 ```
 
 ### Commands
 
 | Command | Description |
 |---------|-------------|
-| `leonai` | Start interactive session |
-| `leonai login <key>` | Save API key |
-| `leonai logout` | Remove API key |
-| `leonai config` | Show config |
+| `shiroai` | Start interactive session |
+| `shiroai login <key>` | Save API key |
+| `shiroai logout` | Remove API key |
+| `shiroai config` | Show config |
 
 ### In-session commands
 

package/cli.js

@@ -1,345 +1,557 @@
 #!/usr/bin/env node
 const readline = require('readline');
 const https = require('https');
+const http = require('http');
 const fs = require('fs');
 const path = require('path');
-const { execSync, spawnSync } = require('child_process');
+const { execSync, spawn } = require('child_process');
+const os = require('os');
 
 // ===== COLORS =====
 const c = {
-    r: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
-    green: '\x1b[32m', cyan: '\x1b[36m', yellow: '\x1b[33m',
-    red: '\x1b[31m', magenta: '\x1b[35m', blue: '\x1b[34m',
-    bg: '\x1b[48;5;236m'
+  r: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m', italic: '\x1b[3m',
+  green: '\x1b[32m', cyan: '\x1b[36m', yellow: '\x1b[33m',
+  red: '\x1b[31m', magenta: '\x1b[35m', blue: '\x1b[34m', white: '\x1b[37m',
+  bgGreen: '\x1b[42m', bgBlue: '\x1b[44m', bgMagenta: '\x1b[45m',
 };
 
 // ===== CONFIG =====
-const API_URL = 'https://inference.do-ai.run/v1/chat/completions';
+const SERVER_URL = process.env.SHIROAI_SERVER || 'http://157.230.42.115:3000';
 const MODEL = 'deepseek-v4-pro';
 const CWD = process.cwd();
-const CONFIG_DIR = path.join(require('os').homedir(), '.shiroai');
+const CONFIG_DIR = path.join(os.homedir(), '.shiroai');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const SESSIONS_DIR = path.join(CONFIG_DIR, 'sessions');
+const AGENTS_DIR = path.join(CONFIG_DIR, 'agents');
 
-// Load or create config
-if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
-function loadConfig() { try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch(e) { return {}; } }
-function saveConfig(cfg) { fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2)); }
+// Ensure dirs
+[CONFIG_DIR, SESSIONS_DIR, AGENTS_DIR].forEach(d => {
+  if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+});
 
+function loadConfig() { try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; } }
+function saveConfig(cfg) { fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2)); }
 let config = loadConfig();
 
-// Handle CLI args
+// ===== CLI ARGS =====
 const args = process.argv.slice(2);
 if (args[0] === 'login') {
-    const key = args[1];
-    if (!key) { console.log('Usage: shiroai login <YOUR_API_KEY>'); process.exit(1); }
-    config.api_key = key;
-    saveConfig(config);
-    console.log(`${c.green}✓ API key saved! You're ready to go.${c.r}`);
-    console.log(`${c.dim}  Run 'shiroai' to start chatting.${c.r}`);
-    process.exit(0);
-}
-if (args[0] === 'logout') {
-    delete config.api_key;
-    saveConfig(config);
-    console.log('Logged out. Run "shiroai login <key>" to re-authenticate.');
-    process.exit(0);
+  if (!args[1]) { console.log('Usage: shiroai login <API_KEY>'); process.exit(1); }
+  config.api_key = args[1]; saveConfig(config);
+  console.log(`${c.green}✓ API key saved!${c.r}`); process.exit(0);
 }
+if (args[0] === 'logout') { delete config.api_key; saveConfig(config); console.log('Logged out.'); process.exit(0); }
 if (args[0] === 'config') {
-    console.log(`Config: ${CONFIG_FILE}`);
-    console.log(`API Key: ${config.api_key ? config.api_key.slice(0, 12) + '...' : '(not set)'}`);
-    console.log(`Model: ${MODEL}`);
-    process.exit(0);
+  console.log(`Config: ${CONFIG_FILE}\nAPI Key: ${config.api_key ? config.api_key.slice(0, 16) + '...' : '(not set)'}\nModel: ${MODEL}`);
+  process.exit(0);
 }
 
-const API_KEY = config.api_key || process.env.LEONAI_KEY || '';
+const API_KEY = config.api_key || process.env.SHIROAI_KEY || '';
 if (!API_KEY) {
-    console.log(`\n${c.bold}${c.green} ✦ ShiroAI CLI${c.r}\n`);
-    console.log(`${c.yellow} You need an API key to use ShiroAI.${c.r}\n`);
-    console.log(`  1. Get your key at ${c.cyan}https://shiroai.dev${c.r}`);
-    console.log(`  2. Run: ${c.green}shiroai login <YOUR_API_KEY>${c.r}\n`);
-    console.log(`  Or set env: ${c.dim}export LEONAI_KEY=your_key${c.r}\n`);
-    process.exit(1);
+  console.log(`\n${c.bold}${c.green} ✦ ShiroAI${c.r}\n\n  ${c.yellow}API key required.${c.r}\n\n  1. Get key at ${c.cyan}https://shiroai.dev${c.r}\n  2. Run: ${c.green}shiroai login <KEY>${c.r}\n`);
+  process.exit(1);
 }
 
-// ===== STATE =====
-const messages = [];
-let autoExec = true;
-
-const SYSTEM = `You are ShiroAI, a powerful AI coding agent running in the user's terminal at: ${CWD}
-
-## CAPABILITIES:
-- Read, create, edit, delete files
-- Run shell commands
-- Debug code
-- Build full projects
-- Analyze codebases
-
-## OUTPUT FORMAT:
-When you need to perform actions, use these EXACT markers:
-
-To create/write a file:
-<<<FILE:path/to/file>>>
-content here
-<<<END>>>
-
-To run a command:
-<<<RUN>>>
-command here
-<<<END>>>
-
-To edit a specific part of a file (find and replace):
-<<<EDIT:path/to/file>>>
-<<<OLD>>>
-old content
-<<<NEW>>>
-new content
-<<<END>>>
-
-## RULES:
-- ALWAYS use the markers above when creating files or running commands. Never just show code without markers.
-- Be concise. Minimal explanation, maximum action.
-- Match user's language.
-- When user says "buatin/bikin/create" → create the files immediately.
-- When debugging → read the file, find bugs, fix with EDIT markers.
-- You can chain multiple FILE and RUN blocks in one response.
-- Current directory: ${CWD}
-- OS: ${process.platform}
-- Available: node, python3, git, bash`;
-
-messages.push({ role: 'system', content: SYSTEM });
+// ===== TOOLS DEFINITION =====
+const TOOLS = [
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read the contents of a file. Use this to understand code before making changes.',
+      parameters: { type: 'object', properties: { path: { type: 'string', description: 'File path relative to CWD' } }, required: ['path'] }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: 'Create or overwrite a file with content.',
+      parameters: { type: 'object', properties: { path: { type: 'string', description: 'File path' }, content: { type: 'string', description: 'File content' } }, required: ['path', 'content'] }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'edit_file',
+      description: 'Edit a file by replacing old text with new text.',
+      parameters: { type: 'object', properties: { path: { type: 'string', description: 'File path' }, old_text: { type: 'string', description: 'Text to find' }, new_text: { type: 'string', description: 'Replacement text' } }, required: ['path', 'old_text', 'new_text'] }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_command',
+      description: 'Execute a shell command and return output. Use for installing deps, running tests, git, etc.',
+      parameters: { type: 'object', properties: { command: { type: 'string', description: 'Shell command to execute' } }, required: ['command'] }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'search_files',
+      description: 'Search for text pattern in files recursively. Returns matching lines with file paths.',
+      parameters: { type: 'object', properties: { pattern: { type: 'string', description: 'Text or regex pattern' }, path: { type: 'string', description: 'Directory to search in (default: .)' } }, required: ['pattern'] }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_directory',
+      description: 'List files and directories. Use to understand project structure.',
+      parameters: { type: 'object', properties: { path: { type: 'string', description: 'Directory path (default: .)' }, recursive: { type: 'boolean', description: 'List recursively (default: false)' } }, required: [] }
+    }
+  }
+];
+
+// ===== TOOL EXECUTION =====
+function executeTool(name, args) {
+  try {
+    switch (name) {
+      case 'read_file': {
+        const fp = path.resolve(CWD, args.path);
+        if (!fs.existsSync(fp)) return { error: `File not found: ${args.path}` };
+        const content = fs.readFileSync(fp, 'utf8');
+        process.stdout.write(`  ${c.dim}📖 Read: ${args.path} (${content.length} chars)${c.r}\n`);
+        return { content };
+      }
+      case 'write_file': {
+        const fp = path.resolve(CWD, args.path);
+        const dir = path.dirname(fp);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(fp, args.content);
+        process.stdout.write(`  ${c.yellow}📄 Created: ${args.path}${c.r}\n`);
+        return { success: true };
+      }
+      case 'edit_file': {
+        const fp = path.resolve(CWD, args.path);
+        if (!fs.existsSync(fp)) return { error: `File not found: ${args.path}` };
+        let content = fs.readFileSync(fp, 'utf8');
+        if (!content.includes(args.old_text)) return { error: 'Old text not found in file' };
+        content = content.replace(args.old_text, args.new_text);
+        fs.writeFileSync(fp, content);
+        process.stdout.write(`  ${c.yellow}✏️  Edited: ${args.path}${c.r}\n`);
+        return { success: true };
+      }
+      case 'run_command': {
+        process.stdout.write(`  ${c.dim}$ ${args.command}${c.r}\n`);
+        try {
+          const out = execSync(args.command, { encoding: 'utf8', timeout: 60000, cwd: CWD, maxBuffer: 5 * 1024 * 1024 });
+          const trimmed = out.trim();
+          if (trimmed) process.stdout.write(`  ${c.green}${trimmed.split('\n').slice(0, 20).join('\n  ')}${c.r}\n`);
+          return { output: trimmed };
+        } catch (e) {
+          const err = (e.stderr || e.stdout || e.message).trim();
+          process.stdout.write(`  ${c.red}${err.split('\n').slice(0, 10).join('\n  ')}${c.r}\n`);
+          return { error: err };
+        }
+      }
+      case 'search_files': {
+        const dir = path.resolve(CWD, args.path || '.');
+        try {
+          const out = execSync(`grep -rn --include="*" "${args.pattern}" "${dir}" 2>/dev/null | head -30`, { encoding: 'utf8', timeout: 10000 });
+          process.stdout.write(`  ${c.dim}🔍 Search: "${args.pattern}"${c.r}\n`);
+          return { results: out.trim() || 'No matches found' };
+        } catch { return { results: 'No matches found' }; }
+      }
+      case 'list_directory': {
+        const dir = path.resolve(CWD, args.path || '.');
+        if (!fs.existsSync(dir)) return { error: `Directory not found: ${args.path}` };
+        const items = listDir(dir, args.recursive ? 2 : 0);
+        process.stdout.write(`  ${c.dim}📂 Listed: ${args.path || '.'}${c.r}\n`);
+        return { files: items };
+      }
+      default: return { error: `Unknown tool: ${name}` };
+    }
+  } catch (e) { return { error: e.message }; }
+}
 
-// ===== UI =====
-function print(text) { process.stdout.write(text); }
-function println(text = '') { console.log(text); }
-function header() {
-    println(`\n${c.bold}${c.green} ✦ ShiroAI CLI ${c.r}${c.dim}v1.0.0${c.r}`);
-    println(`${c.dim} Working in: ${CWD}${c.r}`);
-    println(`${c.dim} Commands: /help /run /read /clear /auto /quit${c.r}\n`);
+function listDir(dir, depth, prefix = '') {
+  if (depth < 0) return [];
+  const items = [];
+  const entries = fs.readdirSync(dir).filter(n => !n.startsWith('.') && n !== 'node_modules' && n !== '__pycache__' && n !== 'dist' && n !== '.git');
+  for (const entry of entries.slice(0, 50)) {
+    const fp = path.join(dir, entry);
+    const stat = fs.statSync(fp);
+    if (stat.isDirectory()) {
+      items.push(prefix + entry + '/');
+      if (depth > 0) items.push(...listDir(fp, depth - 1, prefix + '  '));
+    } else {
+      items.push(prefix + entry);
+    }
+  }
+  return items;
 }
 
-function showHelp() {
-    println(`${c.bold}Commands:${c.r}`);
-    println(`  ${c.cyan}/run <cmd>${c.r}      Run a shell command`);
-    println(`  ${c.cyan}/read <file>${c.r}    Read file and add to context`);
-    println(`  ${c.cyan}/edit <file>${c.r}    Ask AI to edit a file`);
-    println(`  ${c.cyan}/debug <file>${c.r}   Debug a file`);
-    println(`  ${c.cyan}/create${c.r}         Ask AI to create a project`);
-    println(`  ${c.cyan}/tree${c.r}           Show directory structure`);
-    println(`  ${c.cyan}/auto${c.r}           Toggle auto-execute (${autoExec ? 'ON' : 'OFF'})`);
-    println(`  ${c.cyan}/clear${c.r}          Clear conversation`);
-    println(`  ${c.cyan}/quit${c.r}           Exit`);
-    println();
+// ===== AGENTS =====
+const AGENTS = {
+  default: {
+    name: 'default',
+    description: 'Full-featured coding agent',
+    prompt: `You are ShiroAI, a powerful AI coding agent running in the user's terminal.
+Working directory: ${CWD}
+OS: ${process.platform}
+
+You have access to tools to read, write, edit files, run commands, and search code.
+Use tools proactively — read files before editing, check project structure before creating.
+Be concise. Take action, don't just explain. Match user's language.`,
+    tools: TOOLS
+  },
+  plan: {
+    name: 'plan',
+    description: 'Planning agent — analyzes before acting',
+    prompt: `You are ShiroAI in PLANNING mode. You help users plan implementations before coding.
+Working directory: ${CWD}
+
+Your job:
+1. Ask clarifying questions about requirements
+2. Research the codebase using read_file, search_files, list_directory
+3. Create a detailed implementation plan with tasks
+4. DO NOT write or edit files — only read and analyze
+
+Output a structured plan with numbered tasks when ready.`,
+    tools: TOOLS.filter(t => ['read_file', 'search_files', 'list_directory', 'run_command'].includes(t.function.name))
+  }
+};
+
+// Load custom agents
+try {
+  const agentFiles = fs.readdirSync(AGENTS_DIR).filter(f => f.endsWith('.json'));
+  for (const f of agentFiles) {
+    const agent = JSON.parse(fs.readFileSync(path.join(AGENTS_DIR, f), 'utf8'));
+    const name = path.basename(f, '.json');
+    AGENTS[name] = { ...agent, name, tools: agent.tools === 'all' ? TOOLS : TOOLS.filter(t => (agent.tools || []).includes(t.function.name)) };
+  }
+} catch {}
+
+// ===== STATE =====
+let currentAgent = AGENTS.default;
+let messages = [];
+let contextFiles = [];
+let sessionName = null;
+
+function initMessages() {
+  messages = [{ role: 'system', content: currentAgent.prompt }];
+  // Auto-add project context
+  const contextInfo = getProjectContext();
+  if (contextInfo) messages.push({ role: 'system', content: `[Project Context]\n${contextInfo}` });
+}
+
+function getProjectContext() {
+  const parts = [];
+  // Check for common project files
+  const checks = ['package.json', 'Cargo.toml', 'pyproject.toml', 'go.mod', 'Makefile', 'docker-compose.yml'];
+  for (const f of checks) {
+    if (fs.existsSync(path.join(CWD, f))) {
+      try {
+        const content = fs.readFileSync(path.join(CWD, f), 'utf8');
+        parts.push(`[${f}]\n${content.slice(0, 2000)}`);
+      } catch {}
+    }
+  }
+  // Directory listing
+  try {
+    const items = listDir(CWD, 1);
+    parts.push(`[Directory Structure]\n${items.slice(0, 40).join('\n')}`);
+  } catch {}
+  return parts.join('\n\n');
 }
 
-function tree(dir, prefix = '', depth = 0) {
-    if (depth > 3) return '';
-    let out = '';
-    const items = fs.readdirSync(dir).filter(n => !n.startsWith('.') && n !== 'node_modules' && n !== '__pycache__');
-    items.forEach((item, i) => {
-        const fp = path.join(dir, item);
-        const isLast = i === items.length - 1;
-        const connector = isLast ? '└── ' : '├── ';
-        const stat = fs.statSync(fp);
-        if (stat.isDirectory()) {
-            out += `${prefix}${connector}${c.cyan}${item}/${c.r}\n`;
-            out += tree(fp, prefix + (isLast ? '    ' : '│   '), depth + 1);
-        } else {
-            out += `${prefix}${connector}${item}\n`;
+initMessages();
+
+// ===== STREAMING API (via server proxy) =====
+function streamChat(msgs, tools) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      model: MODEL,
+      messages: msgs,
+      tools: tools,
+      stream: true,
+      max_tokens: 8192
+    });
+    const url = new URL(SERVER_URL + '/api/chat');
+    const client = url.protocol === 'https:' ? https : http;
+
+    const req = client.request({
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': API_KEY,
+        'Content-Length': Buffer.byteLength(body)
+      }
+    }, res => {
+      if (res.statusCode !== 200) {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          try { const j = JSON.parse(data); reject(j.error?.message || data); }
+          catch { reject(`HTTP ${res.statusCode}: ${data}`); }
+        });
+        return;
+      }
+
+      let fullContent = '';
+      let toolCalls = [];
+      let buffer = '';
+
+      res.on('data', chunk => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6).trim();
+          if (data === '[DONE]') continue;
+
+          try {
+            const json = JSON.parse(data);
+            const delta = json.choices?.[0]?.delta;
+            if (!delta) continue;
+
+            // Streaming text
+            if (delta.content) {
+              fullContent += delta.content;
+              process.stdout.write(delta.content);
+            }
+
+            // Tool calls
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                if (tc.index !== undefined) {
+                  if (!toolCalls[tc.index]) toolCalls[tc.index] = { id: '', function: { name: '', arguments: '' } };
+                  if (tc.id) toolCalls[tc.index].id = tc.id;
+                  if (tc.function?.name) toolCalls[tc.index].function.name = tc.function.name;
+                  if (tc.function?.arguments) toolCalls[tc.index].function.arguments += tc.function.arguments;
+                }
+              }
+            }
+          } catch {}
         }
+      });
+
+      res.on('end', () => {
+        // Process remaining buffer
+        if (buffer) {
+          const lines = buffer.split('\n');
+          for (const line of lines) {
+            if (!line.startsWith('data: ')) continue;
+            const data = line.slice(6).trim();
+            if (data === '[DONE]') continue;
+            try {
+              const json = JSON.parse(data);
+              const delta = json.choices?.[0]?.delta;
+              if (delta?.content) { fullContent += delta.content; process.stdout.write(delta.content); }
+              if (delta?.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  if (tc.index !== undefined) {
+                    if (!toolCalls[tc.index]) toolCalls[tc.index] = { id: '', function: { name: '', arguments: '' } };
+                    if (tc.id) toolCalls[tc.index].id = tc.id;
+                    if (tc.function?.name) toolCalls[tc.index].function.name = tc.function.name;
+                    if (tc.function?.arguments) toolCalls[tc.index].function.arguments += tc.function.arguments;
+                  }
+                }
+              }
+            } catch {}
+          }
+        }
+        toolCalls = toolCalls.filter(Boolean);
+        resolve({ content: fullContent, tool_calls: toolCalls.length > 0 ? toolCalls : null });
+      });
     });
-    return out;
+
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
 }
 
-// ===== EXECUTION ENGINE =====
-function executeResponse(text) {
-    let actions = 0;
+// ===== CHAT LOOP WITH TOOL USE =====
+async function chat(input) {
+  messages.push({ role: 'user', content: input });
 
-    // FILE blocks
-    const fileRegex = /<<<FILE:(.+?)>>>\n([\s\S]*?)<<<END>>>/g;
-    let m;
-    while ((m = fileRegex.exec(text)) !== null) {
-        const fp = m[1].trim();
-        const content = m[2];
-        const dir = path.dirname(fp);
-        if (dir !== '.') fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(fp, content);
-        println(`  ${c.yellow}📄 Created: ${fp}${c.r}`);
-        actions++;
-    }
+  process.stdout.write(`\n${c.green}✦ ShiroAI${c.r} ${c.dim}[${currentAgent.name}]${c.r}\n`);
 
-    // EDIT blocks
-    const editRegex = /<<<EDIT:(.+?)>>>\n<<<OLD>>>\n([\s\S]*?)<<<NEW>>>\n([\s\S]*?)<<<END>>>/g;
-    while ((m = editRegex.exec(text)) !== null) {
-        const fp = m[1].trim();
-        const old = m[2].trimEnd();
-        const newContent = m[3].trimEnd();
-        if (fs.existsSync(fp)) {
-            let file = fs.readFileSync(fp, 'utf8');
-            if (file.includes(old)) {
-                file = file.replace(old, newContent);
-                fs.writeFileSync(fp, file);
-                println(`  ${c.yellow}✏️  Edited: ${fp}${c.r}`);
-                actions++;
-            } else {
-                println(`  ${c.red}⚠️  Could not find text to replace in ${fp}${c.r}`);
-            }
-        } else {
-            println(`  ${c.red}⚠️  File not found: ${fp}${c.r}`);
-        }
-    }
+  let iterations = 0;
+  const MAX_ITERATIONS = 10;
 
-    // RUN blocks
-    const runRegex = /<<<RUN>>>\n([\s\S]*?)<<<END>>>/g;
-    while ((m = runRegex.exec(text)) !== null) {
-        const cmd = m[1].trim();
-        println(`  ${c.dim}$ ${cmd}${c.r}`);
-        try {
-            const out = execSync(cmd, { encoding: 'utf8', timeout: 30000, cwd: CWD, maxBuffer: 2 * 1024 * 1024 });
-            if (out.trim()) println(`  ${c.green}${out.trim()}${c.r}`);
-            actions++;
-        } catch (e) {
-            println(`  ${c.red}${(e.stderr || e.stdout || e.message).trim()}${c.r}`);
-            actions++;
-        }
+  while (iterations < MAX_ITERATIONS) {
+    iterations++;
+
+    try {
+      const result = await streamChat(messages, currentAgent.tools);
+
+      if (result.content) {
+        process.stdout.write('\n');
+        messages.push({ role: 'assistant', content: result.content });
+      }
+
+      if (!result.tool_calls) break;
+
+      // Process tool calls
+      const assistantMsg = { role: 'assistant', content: result.content || null, tool_calls: result.tool_calls };
+      if (!result.content) messages.push(assistantMsg);
+      else messages[messages.length - 1].tool_calls = result.tool_calls;
+
+      process.stdout.write(`\n${c.dim}─── tools ───${c.r}\n`);
+
+      for (const tc of result.tool_calls) {
+        let args;
+        try { args = JSON.parse(tc.function.arguments); } catch { args = {}; }
+
+        const toolResult = executeTool(tc.function.name, args);
+        messages.push({
+          role: 'tool',
+          tool_call_id: tc.id,
+          content: JSON.stringify(toolResult)
+        });
+      }
+
+      process.stdout.write(`${c.dim}─────────────${c.r}\n\n`);
+
+    } catch (e) {
+      process.stdout.write(`\n${c.red}Error: ${e}${c.r}\n`);
+      break;
     }
+  }
 
-    if (actions > 0) println();
-    return actions;
+  process.stdout.write('\n');
 }
 
-// ===== API =====
-function callAPI(msgs) {
-    return new Promise((resolve, reject) => {
-        const data = JSON.stringify({ model: MODEL, messages: msgs, max_tokens: 4096 });
-        const url = new URL(API_URL);
-        const req = https.request({
-            hostname: url.hostname, path: url.pathname, method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + API_KEY, 'Content-Length': Buffer.byteLength(data) }
-        }, res => {
-            let body = '';
-            res.on('data', c => body += c);
-            res.on('end', () => {
-                try {
-                    const json = JSON.parse(body);
-                    if (json.error) return reject(json.error.message || JSON.stringify(json.error));
-                    const msg = json.choices?.[0]?.message;
-                    resolve(msg?.content || msg?.reasoning_content || 'No response');
-                } catch (e) { reject(body); }
-            });
-        });
-        req.on('error', reject);
-        req.write(data);
-        req.end();
-    });
+// ===== SESSION MANAGEMENT =====
+function saveSession(name) {
+  const session = { name, agent: currentAgent.name, messages, contextFiles, timestamp: Date.now() };
+  fs.writeFileSync(path.join(SESSIONS_DIR, `${name}.json`), JSON.stringify(session));
+  process.stdout.write(`${c.green}✓ Session saved: ${name}${c.r}\n`);
 }
 
-// ===== CHAT =====
-async function chat(input) {
-    messages.push({ role: 'user', content: input });
-    print(`\n${c.green}✦ ShiroAI${c.r} ${c.dim}thinking...${c.r}`);
+function loadSession(name) {
+  const fp = path.join(SESSIONS_DIR, `${name}.json`);
+  if (!fs.existsSync(fp)) { process.stdout.write(`${c.red}Session not found: ${name}${c.r}\n`); return; }
+  const session = JSON.parse(fs.readFileSync(fp, 'utf8'));
+  messages = session.messages;
+  contextFiles = session.contextFiles || [];
+  if (AGENTS[session.agent]) currentAgent = AGENTS[session.agent];
+  sessionName = name;
+  process.stdout.write(`${c.green}✓ Session loaded: ${name} (${messages.length} messages)${c.r}\n`);
+}
 
+function listSessions() {
+  const files = fs.readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.json'));
+  if (!files.length) { process.stdout.write(`${c.dim}No saved sessions.${c.r}\n`); return; }
+  process.stdout.write(`${c.bold}Saved sessions:${c.r}\n`);
+  for (const f of files) {
     try {
-        const reply = await callAPI(messages);
-        // Clear "thinking..." line
-        if (process.stdout.isTTY) { process.stdout.clearLine(0); process.stdout.cursorTo(0); }
-        else println();
-
-        // Print reply (strip action markers for display)
-        const display = reply
-            .replace(/<<<FILE:.+?>>>\n[\s\S]*?<<<END>>>/g, '')
-            .replace(/<<<EDIT:.+?>>>\n[\s\S]*?<<<END>>>/g, '')
-            .replace(/<<<RUN>>>\n[\s\S]*?<<<END>>>/g, '')
-            .trim();
-
-        if (display) println(`${c.green}✦ ShiroAI:${c.r} ${display}\n`);
-
-        messages.push({ role: 'assistant', content: reply });
-
-        // Execute actions
-        if (autoExec) {
-            executeResponse(reply);
-        } else {
-            const hasActions = /<<<(FILE|RUN|EDIT)/.test(reply);
-            if (hasActions) {
-                println(`${c.yellow}  Actions detected. Run /exec to execute.${c.r}\n`);
-            }
-        }
-    } catch (e) {
-        if (process.stdout.isTTY) { process.stdout.clearLine?.(0); process.stdout.cursorTo?.(0); }
-        println(`${c.red}Error: ${e}${c.r}\n`);
-    }
+      const s = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), 'utf8'));
+      const date = new Date(s.timestamp).toLocaleDateString();
+      process.stdout.write(`  ${c.cyan}${s.name}${c.r} ${c.dim}(${date}, ${s.messages.length} msgs, agent: ${s.agent})${c.r}\n`);
+    } catch {}
+  }
 }
 
-// ===== MAIN LOOP =====
-header();
+// ===== CONTEXT MANAGEMENT =====
+function addContext(filePath) {
+  const fp = path.resolve(CWD, filePath);
+  if (!fs.existsSync(fp)) { process.stdout.write(`${c.red}File not found: ${filePath}${c.r}\n`); return; }
+  const content = fs.readFileSync(fp, 'utf8');
+  contextFiles.push(filePath);
+  messages.push({ role: 'system', content: `[Context: ${filePath}]\n${content}` });
+  process.stdout.write(`${c.dim}+ Added to context: ${filePath} (${content.length} chars)${c.r}\n`);
+}
 
-const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+function showContext() {
+  const totalTokens = messages.reduce((sum, m) => sum + Math.ceil((m.content || '').length / 4), 0);
+  process.stdout.write(`${c.bold}Context:${c.r}\n`);
+  process.stdout.write(`  ${c.dim}Messages: ${messages.length}${c.r}\n`);
+  process.stdout.write(`  ${c.dim}~Tokens: ${totalTokens}${c.r}\n`);
+  process.stdout.write(`  ${c.dim}Agent: ${currentAgent.name}${c.r}\n`);
+  if (contextFiles.length) {
+    process.stdout.write(`  ${c.dim}Files:${c.r}\n`);
+    contextFiles.forEach(f => process.stdout.write(`    ${c.cyan}${f}${c.r}\n`));
+  }
+}
 
-function prompt() {
-    rl.question(`${c.cyan}❯ ${c.r}`, async (input) => {
-        input = input.trim();
-        if (!input) return prompt();
-
-        // Commands
-        if (input === '/quit' || input === '/exit' || input === '/q') { println('👋 Bye!'); process.exit(0); }
-        if (input === '/clear') { messages.length = 1; println(`${c.dim}Conversation cleared.${c.r}\n`); return prompt(); }
-        if (input === '/help' || input === '/?') { showHelp(); return prompt(); }
-        if (input === '/auto') { autoExec = !autoExec; println(`${c.dim}Auto-execute: ${autoExec ? 'ON' : 'OFF'}${c.r}\n`); return prompt(); }
-        if (input === '/tree') { println(tree(CWD)); return prompt(); }
-        if (input === '/exec') {
-            const last = messages[messages.length - 1];
-            if (last?.role === 'assistant') executeResponse(last.content);
-            return prompt();
-        }
+// ===== UI =====
+function header() {
+  console.log(`\n${c.bold}${c.green} ✦ ShiroAI${c.r} ${c.dim}v2.0.0${c.r}`);
+  console.log(`${c.dim} ${CWD}${c.r}`);
+  console.log(`${c.dim} Agent: ${currentAgent.name} | Model: ${MODEL}${c.r}`);
+  console.log(`${c.dim} /help for commands${c.r}\n`);
+}
 
-        if (input.startsWith('/run ')) {
-            const cmd = input.slice(5);
-            println(`${c.dim}$ ${cmd}${c.r}`);
-            try { const out = execSync(cmd, { encoding: 'utf8', timeout: 30000, cwd: CWD }); if (out.trim()) println(out.trim()); } catch (e) { println(`${c.red}${e.stderr || e.message}${c.r}`); }
-            println();
-            return prompt();
-        }
+function showHelp() {
+  console.log(`${c.bold}Commands:${c.r}`);
+  console.log(`  ${c.cyan}/help${c.r}              Show this help`);
+  console.log(`  ${c.cyan}/context${c.r}           Show context info`);
+  console.log(`  ${c.cyan}/context add <f>${c.r}   Add file to context`);
+  console.log(`  ${c.cyan}/chat save <name>${c.r}  Save session`);
+  console.log(`  ${c.cyan}/chat load <name>${c.r}  Load session`);
+  console.log(`  ${c.cyan}/chat list${c.r}         List sessions`);
+  console.log(`  ${c.cyan}/agent${c.r}             Show current agent`);
+  console.log(`  ${c.cyan}/agent <name>${c.r}      Switch agent`);
+  console.log(`  ${c.cyan}/agent list${c.r}        List agents`);
+  console.log(`  ${c.cyan}/plan${c.r}              Switch to planning mode`);
+  console.log(`  ${c.cyan}/clear${c.r}             Clear conversation`);
+  console.log(`  ${c.cyan}/quit${c.r}              Exit`);
+  console.log();
+}
 
-        if (input.startsWith('/read ')) {
-            const fp = input.slice(6);
-            if (fs.existsSync(fp)) {
-                const content = fs.readFileSync(fp, 'utf8');
-                println(`${c.dim}Read ${fp} (${content.length} chars)${c.r}\n`);
-                messages.push({ role: 'user', content: `[File: ${fp}]\n${content}` });
-            } else { println(`${c.red}File not found: ${fp}${c.r}\n`); }
-            return prompt();
-        }
+// ===== MAIN =====
+header();
 
-        if (input.startsWith('/edit ')) {
-            const fp = input.slice(6);
-            if (fs.existsSync(fp)) {
-                const content = fs.readFileSync(fp, 'utf8');
-                await chat(`Edit this file (${fp}):\n\`\`\`\n${content}\n\`\`\`\nWhat should I change?`);
-            } else { println(`${c.red}File not found: ${fp}${c.r}\n`); }
-            return prompt();
-        }
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
-        if (input.startsWith('/debug ')) {
-            const fp = input.slice(7);
-            if (fs.existsSync(fp)) {
-                const content = fs.readFileSync(fp, 'utf8');
-                await chat(`Debug this file (${fp}). Find all bugs and fix them:\n\`\`\`\n${content}\n\`\`\``);
-            } else { println(`${c.red}File not found: ${fp}${c.r}\n`); }
-            return prompt();
-        }
+function prompt() {
+  const agentTag = currentAgent.name !== 'default' ? `${c.dim}[${currentAgent.name}]${c.r} ` : '';
+  rl.question(`${agentTag}${c.cyan}❯ ${c.r}`, async (input) => {
+    input = input.trim();
+    if (!input) return prompt();
+
+    // Commands
+    if (input === '/quit' || input === '/q' || input === '/exit') { console.log('👋'); process.exit(0); }
+    if (input === '/help' || input === '/?') { showHelp(); return prompt(); }
+    if (input === '/clear') { initMessages(); contextFiles = []; console.log(`${c.dim}Cleared.${c.r}`); return prompt(); }
+    if (input === '/context') { showContext(); return prompt(); }
+    if (input.startsWith('/context add ')) { addContext(input.slice(13)); return prompt(); }
+
+    // Session commands
+    if (input.startsWith('/chat save ')) { saveSession(input.slice(11).trim()); return prompt(); }
+    if (input.startsWith('/chat load ')) { loadSession(input.slice(11).trim()); return prompt(); }
+    if (input === '/chat list') { listSessions(); return prompt(); }
+
+    // Agent commands
+    if (input === '/agent') { console.log(`${c.dim}Current: ${currentAgent.name} — ${currentAgent.description || ''}${c.r}`); return prompt(); }
+    if (input === '/agent list') {
+      console.log(`${c.bold}Agents:${c.r}`);
+      Object.values(AGENTS).forEach(a => console.log(`  ${c.cyan}${a.name}${c.r} ${c.dim}— ${a.description || ''}${c.r}`));
+      return prompt();
+    }
+    if (input.startsWith('/agent ')) {
+      const name = input.slice(7).trim();
+      if (AGENTS[name]) {
+        currentAgent = AGENTS[name];
+        initMessages();
+        console.log(`${c.green}✓ Switched to agent: ${name}${c.r}`);
+      } else { console.log(`${c.red}Agent not found: ${name}${c.r}`); }
+      return prompt();
+    }
 
-        if (input === '/create') {
-            rl.question(`${c.dim}What to create? ${c.r}`, async (desc) => {
-                if (desc.trim()) await chat(`Create this project: ${desc}`);
-                prompt();
-            });
-            return;
-        }
+    // Plan mode shortcut
+    if (input === '/plan') {
+      currentAgent = AGENTS.plan;
+      initMessages();
+      console.log(`${c.green}✓ Planning mode. I'll analyze before acting.${c.r}`);
+      console.log(`${c.dim}  Use /agent default to switch back.${c.r}`);
+      return prompt();
+    }
 
-        // Regular chat
-        await chat(input);
-        prompt();
-    });
+    // Regular chat with tool use
+    await chat(input);
+    prompt();
+  });
 }
 
 prompt();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shiroai",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "AI coding agent for your terminal — create, edit, debug, and deploy from the command line",
   "bin": {
     "shiroai": "./cli.js"
@@ -8,15 +8,25 @@
   "files": [
     "cli.js"
   ],
-  "keywords": ["ai", "cli", "coding", "agent", "terminal", "gpt", "copilot", "developer-tools"],
-  "author": "LeonAI",
+  "keywords": [
+    "ai",
+    "cli",
+    "coding",
+    "agent",
+    "terminal",
+    "gpt",
+    "copilot",
+    "developer-tools",
+    "shiroai"
+  ],
+  "author": "ShiroAI",
   "license": "MIT",
   "engines": {
     "node": ">=16.0.0"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/leonai/cli"
+    "url": "https://github.com/shiroai/cli"
   },
-  "homepage": "https://leonai.dev"
+  "homepage": "https://shiroai.dev"
 }