@alia-codea/cli 1.0.0

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@alia-codea/cli",
+  "version": "1.0.0",
+  "description": "Codea CLI - AI coding assistant for your terminal by Alia",
+  "main": "dist/index.js",
+  "bin": {
+    "codea": "./dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "eslint src",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "coding",
+    "assistant",
+    "terminal",
+    "alia",
+    "codea"
+  ],
+  "author": "Alia",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^13.0.1",
+    "ink": "^5.0.1",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "marked": "^15.0.4",
+    "marked-terminal": "^7.2.1",
+    "openai": "^6.16.0",
+    "ora": "^8.1.1",
+    "react": "^18.3.1",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "@types/react": "^18.3.12",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/commands/auth.ts

@@ -0,0 +1,66 @@
+import * as readline from 'readline';
+import chalk from 'chalk';
+import { config } from '../utils/config.js';
+import { printSuccess, printError, printInfo } from '../utils/ui.js';
+
+export async function login(): Promise<void> {
+  console.log();
+  console.log(chalk.bold('Codea CLI Login'));
+  console.log(chalk.gray('Enter your Alia API key to get started.'));
+  console.log(chalk.gray('Get your API key at: ') + chalk.cyan('https://alia.onl/settings/api'));
+  console.log();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(chalk.cyan('API Key: '), async (apiKey) => {
+      rl.close();
+
+      const trimmedKey = apiKey.trim();
+
+      if (!trimmedKey) {
+        printError('No API key provided.');
+        resolve();
+        return;
+      }
+
+      // Validate the API key by making a test request
+      printInfo('Validating API key...');
+
+      try {
+        const baseUrl = config.get('apiBaseUrl') || 'https://api.alia.onl';
+        const response = await fetch(`${baseUrl}/codea/me`, {
+          headers: {
+            'Authorization': `Bearer ${trimmedKey}`
+          }
+        });
+
+        if (response.ok) {
+          const data = await response.json();
+          config.set('apiKey', trimmedKey);
+          console.log();
+          printSuccess(`Logged in successfully!`);
+          if (data.name) {
+            console.log(chalk.gray(`Welcome, ${data.name}!`));
+          }
+          console.log();
+          console.log(chalk.gray('Run ') + chalk.cyan('codea') + chalk.gray(' to start coding.'));
+        } else {
+          printError('Invalid API key. Please check and try again.');
+        }
+      } catch (error: any) {
+        printError(`Could not validate API key: ${error.message}`);
+      }
+
+      resolve();
+    });
+  });
+}
+
+export function logout(): void {
+  config.delete('apiKey');
+  printSuccess('Logged out successfully.');
+}

package/src/commands/repl.ts

@@ -0,0 +1,309 @@
+import * as readline from 'readline';
+import chalk from 'chalk';
+import { config, createSession, saveSession } from '../utils/config.js';
+import { streamChat } from '../utils/api.js';
+import { executeTool, formatToolCall } from '../tools/executor.js';
+import {
+  printBanner,
+  printTips,
+  printPrompt,
+  printToolExecution,
+  printToolResult,
+  showThinkingStatus,
+  hideThinkingStatus,
+  printStatusBar,
+  printAssistantPrefix,
+  printError,
+  printInfo
+} from '../utils/ui.js';
+import { buildSystemMessage, getCodebaseContext } from '../utils/context.js';
+
+interface Message {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  tool_calls?: any[];
+  tool_call_id?: string;
+}
+
+interface ReplOptions {
+  model: string;
+  context: boolean;
+}
+
+export async function startRepl(options: ReplOptions): Promise<void> {
+  const session = createSession();
+  const messages: Message[] = [];
+  let isProcessing = false;
+  let contextUsed = 0;
+  const maxContext = 128000;
+
+  // Print welcome UI
+  printTips();
+
+  // Get initial codebase context
+  let codebaseContext = '';
+  if (options.context !== false) {
+    printInfo('Analyzing codebase...');
+    codebaseContext = await getCodebaseContext();
+    if (codebaseContext) {
+      printInfo(`Loaded context from ${codebaseContext.split('\n').length} files`);
+    }
+  }
+
+  // Setup readline
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+
+  // Handle Ctrl+C
+  rl.on('SIGINT', () => {
+    if (isProcessing) {
+      isProcessing = false;
+      hideThinkingStatus();
+      console.log(chalk.yellow('\nCancelled.'));
+      printPrompt();
+    } else {
+      console.log(chalk.gray('\nGoodbye!'));
+      process.exit(0);
+    }
+  });
+
+  const askQuestion = (): void => {
+    printPrompt();
+    rl.question('', async (input) => {
+      const trimmed = input.trim();
+
+      if (!trimmed) {
+        askQuestion();
+        return;
+      }
+
+      // Handle slash commands
+      if (trimmed.startsWith('/')) {
+        await handleSlashCommand(trimmed, messages, session, options);
+        askQuestion();
+        return;
+      }
+
+      // Add user message
+      messages.push({ role: 'user', content: trimmed });
+      isProcessing = true;
+
+      // Build system message
+      const systemMessage = buildSystemMessage(options.model, codebaseContext);
+
+      // Process conversation with tool loop
+      await processConversation(messages, systemMessage, options.model, () => isProcessing);
+
+      isProcessing = false;
+
+      // Update session
+      session.messages = messages.map(m => ({ role: m.role, content: m.content }));
+      session.title = messages[0]?.content.slice(0, 50) || 'New conversation';
+      session.updatedAt = Date.now();
+      saveSession(session);
+
+      // Update context usage estimate
+      contextUsed = Math.min(95, Math.floor(messages.reduce((acc, m) => acc + m.content.length, 0) / maxContext * 100));
+
+      // Print status bar
+      printStatusBar(process.cwd(), getModelDisplayName(options.model), 100 - contextUsed);
+
+      askQuestion();
+    });
+  };
+
+  askQuestion();
+}
+
+async function processConversation(
+  messages: Message[],
+  systemMessage: string,
+  model: string,
+  isActive: () => boolean
+): Promise<void> {
+  while (isActive()) {
+    console.log();
+    printAssistantPrefix();
+
+    let fullContent = '';
+    let toolCalls: any[] | undefined;
+
+    showThinkingStatus('Thinking');
+
+    try {
+      await streamChat(messages, systemMessage, model, {
+        onContent: (content) => {
+          if (!isActive()) return;
+          hideThinkingStatus();
+          process.stdout.write(content);
+          fullContent += content;
+        },
+        onToolCall: (tc) => {
+          // Tool calls are accumulated
+        },
+        onDone: (content, tcs) => {
+          hideThinkingStatus();
+          toolCalls = tcs;
+        },
+        onError: (error) => {
+          hideThinkingStatus();
+          printError(error.message);
+        }
+      });
+    } catch (error: any) {
+      hideThinkingStatus();
+      printError(error.message);
+      break;
+    }
+
+    if (!isActive()) break;
+
+    // Handle tool calls
+    if (toolCalls && toolCalls.length > 0) {
+      // Add assistant message with tool calls
+      messages.push({
+        role: 'assistant',
+        content: fullContent,
+        tool_calls: toolCalls
+      });
+
+      if (fullContent) {
+        console.log(); // New line after content
+      }
+
+      // Execute each tool
+      for (const tc of toolCalls) {
+        if (!isActive()) break;
+
+        const args = JSON.parse(tc.function.arguments);
+        printToolExecution(tc.function.name, formatToolArgs(tc.function.name, args));
+
+        showThinkingStatus(`Executing ${tc.function.name}`);
+        const result = await executeTool(tc.function.name, args);
+        hideThinkingStatus();
+
+        printToolResult(result.success, result.result);
+
+        // Add tool result
+        messages.push({
+          role: 'tool',
+          tool_call_id: tc.id,
+          content: result.result
+        });
+      }
+
+      // Continue loop for next response
+      continue;
+    } else {
+      // No tool calls, conversation turn complete
+      if (fullContent) {
+        messages.push({ role: 'assistant', content: fullContent });
+        console.log(); // New line after response
+      }
+      break;
+    }
+  }
+}
+
+async function handleSlashCommand(
+  command: string,
+  messages: Message[],
+  session: any,
+  options: ReplOptions
+): Promise<void> {
+  const [cmd, ...args] = command.slice(1).split(' ');
+
+  switch (cmd.toLowerCase()) {
+    case 'help':
+      console.log();
+      console.log(chalk.bold('Available commands:'));
+      console.log(chalk.cyan('  /help') + chalk.gray('     - Show this help'));
+      console.log(chalk.cyan('  /clear') + chalk.gray('    - Clear conversation'));
+      console.log(chalk.cyan('  /model') + chalk.gray('    - Switch model'));
+      console.log(chalk.cyan('  /context') + chalk.gray('  - Show current context'));
+      console.log(chalk.cyan('  /save') + chalk.gray('     - Save conversation'));
+      console.log(chalk.cyan('  /exit') + chalk.gray('     - Exit Codea'));
+      console.log();
+      break;
+
+    case 'clear':
+      messages.length = 0;
+      console.log(chalk.green('Conversation cleared.'));
+      break;
+
+    case 'model':
+      const modelArg = args[0];
+      if (modelArg) {
+        options.model = modelArg.startsWith('alia-') ? modelArg : `alia-v1-${modelArg}`;
+        console.log(chalk.green(`Model switched to ${options.model}`));
+      } else {
+        console.log(chalk.gray('Current model: ') + chalk.cyan(options.model));
+        try {
+          const { fetchModels } = await import('../utils/api.js');
+          const apiModels = await fetchModels();
+          if (apiModels.length > 0) {
+            console.log(chalk.gray('Available models:'));
+            for (const m of apiModels) {
+              console.log(chalk.gray('  ') + chalk.cyan(m.id) + chalk.gray(` - ${m.name}`));
+            }
+          } else {
+            console.log(chalk.gray('Available: codea, codea-pro, codea-thinking'));
+          }
+        } catch {
+          console.log(chalk.gray('Available: codea, codea-pro, codea-thinking'));
+        }
+      }
+      break;
+
+    case 'context':
+      console.log(chalk.gray(`Messages in context: ${messages.length}`));
+      console.log(chalk.gray(`Working directory: ${process.cwd()}`));
+      break;
+
+    case 'save':
+      session.messages = messages.map(m => ({ role: m.role, content: m.content }));
+      session.updatedAt = Date.now();
+      saveSession(session);
+      console.log(chalk.green('Conversation saved.'));
+      break;
+
+    case 'exit':
+    case 'quit':
+      console.log(chalk.gray('Goodbye!'));
+      process.exit(0);
+      break;
+
+    default:
+      console.log(chalk.yellow(`Unknown command: /${cmd}`));
+      console.log(chalk.gray('Type /help for available commands.'));
+  }
+}
+
+function formatToolArgs(name: string, args: Record<string, any>): string {
+  switch (name) {
+    case 'read_file':
+    case 'write_file':
+    case 'edit_file':
+      return args.path || '';
+    case 'list_files':
+      return args.path || '.';
+    case 'search_files':
+      return `"${args.pattern}" in ${args.path || '.'}`;
+    case 'run_command':
+      return args.command || '';
+    default:
+      return JSON.stringify(args).slice(0, 50);
+  }
+}
+
+function getModelDisplayName(model: string): string {
+  const names: Record<string, string> = {
+    'alia-v1-codea': 'codea',
+    'alia-v1-pro': 'codea-pro',
+    'alia-v1-thinking': 'codea-thinking'
+  };
+  return names[model] || model;
+}

package/src/commands/run.ts

@@ -0,0 +1,177 @@
+import chalk from 'chalk';
+import { config } from '../utils/config.js';
+import { streamChat } from '../utils/api.js';
+import { executeTool, formatToolCall } from '../tools/executor.js';
+import { buildSystemMessage, getCodebaseContext } from '../utils/context.js';
+import {
+  printToolExecution,
+  printToolResult,
+  showThinkingStatus,
+  hideThinkingStatus,
+  printAssistantPrefix,
+  printError,
+  printInfo
+} from '../utils/ui.js';
+
+interface Message {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  tool_calls?: any[];
+  tool_call_id?: string;
+}
+
+interface RunOptions {
+  model: string;
+  yes: boolean;
+  context: boolean;
+}
+
+export async function runPrompt(prompt: string, options: RunOptions): Promise<void> {
+  const messages: Message[] = [];
+
+  // Get codebase context
+  let codebaseContext = '';
+  if (options.context !== false) {
+    codebaseContext = await getCodebaseContext();
+  }
+
+  // Add user message
+  messages.push({ role: 'user', content: prompt });
+
+  // Build system message
+  const systemMessage = buildSystemMessage(options.model, codebaseContext);
+
+  // Process with tool loop
+  await processConversation(messages, systemMessage, options.model, options.yes);
+}
+
+async function processConversation(
+  messages: Message[],
+  systemMessage: string,
+  model: string,
+  autoApprove: boolean
+): Promise<void> {
+  let continueProcessing = true;
+
+  while (continueProcessing) {
+    printAssistantPrefix();
+
+    let fullContent = '';
+    let toolCalls: any[] | undefined;
+
+    showThinkingStatus('Thinking');
+
+    try {
+      await streamChat(messages, systemMessage, model, {
+        onContent: (content) => {
+          hideThinkingStatus();
+          process.stdout.write(content);
+          fullContent += content;
+        },
+        onToolCall: () => {},
+        onDone: (content, tcs) => {
+          hideThinkingStatus();
+          toolCalls = tcs;
+        },
+        onError: (error) => {
+          hideThinkingStatus();
+          printError(error.message);
+          continueProcessing = false;
+        }
+      });
+    } catch (error: any) {
+      hideThinkingStatus();
+      printError(error.message);
+      break;
+    }
+
+    // Handle tool calls
+    if (toolCalls && toolCalls.length > 0) {
+      messages.push({
+        role: 'assistant',
+        content: fullContent,
+        tool_calls: toolCalls
+      });
+
+      if (fullContent) console.log();
+
+      for (const tc of toolCalls) {
+        const args = JSON.parse(tc.function.arguments);
+
+        // Check if we need approval for file writes
+        const isDestructive = ['write_file', 'edit_file', 'run_command'].includes(tc.function.name);
+
+        if (isDestructive && !autoApprove) {
+          console.log();
+          console.log(chalk.yellow('⚠ ') + chalk.bold('Approval required:'));
+          console.log(formatToolCall(tc.function.name, args));
+          console.log();
+
+          const approved = await askApproval();
+          if (!approved) {
+            messages.push({
+              role: 'tool',
+              tool_call_id: tc.id,
+              content: 'User declined this action.'
+            });
+            continue;
+          }
+        }
+
+        printToolExecution(tc.function.name, formatToolArgs(tc.function.name, args));
+
+        showThinkingStatus(`Executing ${tc.function.name}`);
+        const result = await executeTool(tc.function.name, args);
+        hideThinkingStatus();
+
+        printToolResult(result.success, result.result);
+
+        messages.push({
+          role: 'tool',
+          tool_call_id: tc.id,
+          content: result.result
+        });
+      }
+
+      continue;
+    } else {
+      if (fullContent) {
+        messages.push({ role: 'assistant', content: fullContent });
+        console.log();
+      }
+      break;
+    }
+  }
+}
+
+async function askApproval(): Promise<boolean> {
+  const readline = await import('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(chalk.cyan('Allow? [y/N] '), (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+function formatToolArgs(name: string, args: Record<string, any>): string {
+  switch (name) {
+    case 'read_file':
+    case 'write_file':
+    case 'edit_file':
+      return args.path || '';
+    case 'list_files':
+      return args.path || '.';
+    case 'search_files':
+      return `"${args.pattern}" in ${args.path || '.'}`;
+    case 'run_command':
+      return args.command || '';
+    default:
+      return JSON.stringify(args).slice(0, 50);
+  }
+}