@alia-codea/cli 1.0.0

package/src/commands/sessions.ts

@@ -0,0 +1,122 @@
+import chalk from 'chalk';
+import * as readline from 'readline';
+import { getSessions, getSession, config } from '../utils/config.js';
+import { startRepl } from './repl.js';
+import { printBanner, printError, printInfo } from '../utils/ui.js';
+
+export async function listSessions(): Promise<void> {
+  const sessions = getSessions();
+
+  if (sessions.length === 0) {
+    printInfo('No saved sessions found.');
+    console.log(chalk.gray('Start a new session with: ') + chalk.cyan('codea'));
+    return;
+  }
+
+  console.log();
+  console.log(chalk.bold('Recent Sessions'));
+  console.log(chalk.gray('─'.repeat(60)));
+
+  sessions.slice(0, 10).forEach((session, index) => {
+    const date = new Date(session.updatedAt).toLocaleDateString();
+    const time = new Date(session.updatedAt).toLocaleTimeString();
+    const messageCount = session.messages?.length || 0;
+    const title = session.title.slice(0, 40) + (session.title.length > 40 ? '...' : '');
+
+    console.log(
+      chalk.cyan(`${index + 1}.`) + ' ' +
+      chalk.white(title) + ' ' +
+      chalk.gray(`(${messageCount} msgs, ${date} ${time})`)
+    );
+  });
+
+  console.log();
+  console.log(chalk.gray('Resume a session with: ') + chalk.cyan('codea resume <number>'));
+}
+
+export async function resumeSession(sessionId?: string): Promise<void> {
+  const sessions = getSessions();
+
+  if (sessions.length === 0) {
+    printInfo('No saved sessions found.');
+    return;
+  }
+
+  let selectedSession;
+
+  if (sessionId) {
+    // Try to find by index (1-based) or ID
+    const index = parseInt(sessionId) - 1;
+    if (!isNaN(index) && index >= 0 && index < sessions.length) {
+      selectedSession = sessions[index];
+    } else {
+      selectedSession = getSession(sessionId);
+    }
+
+    if (!selectedSession) {
+      printError(`Session not found: ${sessionId}`);
+      return;
+    }
+  } else {
+    // Show picker
+    console.log();
+    console.log(chalk.bold('Select a session to resume:'));
+    console.log();
+
+    sessions.slice(0, 10).forEach((session, index) => {
+      const date = new Date(session.updatedAt).toLocaleDateString();
+      const title = session.title.slice(0, 50) + (session.title.length > 50 ? '...' : '');
+      console.log(chalk.cyan(`  ${index + 1}.`) + ' ' + title + ' ' + chalk.gray(`(${date})`));
+    });
+
+    console.log();
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+      rl.question(chalk.cyan('Enter number: '), (answer) => {
+        rl.close();
+
+        const index = parseInt(answer) - 1;
+        if (isNaN(index) || index < 0 || index >= sessions.length) {
+          printError('Invalid selection.');
+          resolve();
+          return;
+        }
+
+        selectedSession = sessions[index];
+        startRestoredSession(selectedSession).then(resolve);
+      });
+    });
+  }
+
+  if (selectedSession) {
+    await startRestoredSession(selectedSession);
+  }
+}
+
+async function startRestoredSession(session: any): Promise<void> {
+  printInfo(`Resuming: ${session.title}`);
+  console.log();
+
+  // Display previous messages
+  for (const msg of session.messages || []) {
+    if (msg.role === 'user') {
+      console.log(chalk.cyan('❯ ') + msg.content);
+    } else if (msg.role === 'assistant') {
+      console.log(chalk.magenta('✦ ') + msg.content.slice(0, 200) + (msg.content.length > 200 ? '...' : ''));
+    }
+    console.log();
+  }
+
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(chalk.gray('Session restored. Continue the conversation below.'));
+  console.log();
+
+  // Start REPL with restored session
+  const model = config.get('defaultModel') || 'alia-v1-codea';
+  await startRepl({ model, context: true });
+}

package/src/index.ts

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { config } from './utils/config.js';
+import { startRepl } from './commands/repl.js';
+import { runPrompt } from './commands/run.js';
+import { login } from './commands/auth.js';
+import { listSessions, resumeSession } from './commands/sessions.js';
+import chalk from 'chalk';
+
+const VERSION = '1.0.0';
+
+const program = new Command();
+
+// ASCII art banner
+const banner = `
+${chalk.cyan('   ____          _            ')}
+${chalk.cyan('  / ___|___   __| | ___  __ _ ')}
+${chalk.cyan(' | |   / _ \\ / _\` |/ _ \\/ _\` |')}
+${chalk.cyan(' | |__| (_) | (_| |  __/ (_| |')}
+${chalk.cyan('  \\____\\___/ \\__,_|\\___|\\__,_|')}
+${chalk.gray('  AI Coding Assistant by Alia')}
+`;
+
+program
+  .name('codea')
+  .description('Codea CLI - AI coding assistant for your terminal')
+  .version(VERSION)
+  .hook('preAction', () => {
+    // Check for API key before running commands (except login)
+    const command = program.args[0];
+    if (command !== 'login' && command !== 'help' && !config.get('apiKey')) {
+      console.log(chalk.yellow('\nNo API key found. Please run `codea login` first.\n'));
+      process.exit(1);
+    }
+  });
+
+// Default command - start REPL
+program
+  .command('chat', { isDefault: true })
+  .description('Start an interactive chat session')
+  .option('-m, --model <model>', 'Model to use (codea, codea-pro, codea-thinking)', 'alia-v1-codea')
+  .option('--no-context', 'Disable automatic codebase context')
+  .action(async (options) => {
+    console.log(banner);
+    await startRepl(options);
+  });
+
+// Run a single prompt
+program
+  .command('run <prompt>')
+  .alias('r')
+  .description('Run a single prompt and exit')
+  .option('-m, --model <model>', 'Model to use', 'alia-v1-codea')
+  .option('-y, --yes', 'Auto-approve all file changes')
+  .option('--no-context', 'Disable automatic codebase context')
+  .action(async (prompt, options) => {
+    await runPrompt(prompt, options);
+  });
+
+// Login/configure
+program
+  .command('login')
+  .description('Configure your Alia API key')
+  .action(async () => {
+    await login();
+  });
+
+// Session management
+program
+  .command('sessions')
+  .alias('s')
+  .description('List recent chat sessions')
+  .action(async () => {
+    await listSessions();
+  });
+
+program
+  .command('resume [sessionId]')
+  .description('Resume a previous chat session')
+  .action(async (sessionId) => {
+    console.log(banner);
+    await resumeSession(sessionId);
+  });
+
+// Parse and run
+program.parse();

package/src/tools/executor.ts

@@ -0,0 +1,191 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { glob } from 'fs/promises';
+import chalk from 'chalk';
+
+const execAsync = promisify(exec);
+
+interface ToolResult {
+  success: boolean;
+  result: string;
+}
+
+export async function executeTool(name: string, args: Record<string, any>): Promise<ToolResult> {
+  try {
+    switch (name) {
+      case 'read_file':
+        return await readFile(args.path);
+      case 'write_file':
+        return await writeFile(args.path, args.content);
+      case 'edit_file':
+        return await editFile(args.path, args.old_text, args.new_text);
+      case 'list_files':
+        return await listFiles(args.path, args.recursive);
+      case 'search_files':
+        return await searchFiles(args.pattern, args.path, args.file_pattern);
+      case 'run_command':
+        return await runCommand(args.command, args.cwd);
+      default:
+        return { success: false, result: `Unknown tool: ${name}` };
+    }
+  } catch (error: any) {
+    return { success: false, result: error.message };
+  }
+}
+
+async function readFile(filePath: string): Promise<ToolResult> {
+  const absolutePath = path.resolve(process.cwd(), filePath);
+  const content = await fs.readFile(absolutePath, 'utf-8');
+  return { success: true, result: content };
+}
+
+async function writeFile(filePath: string, content: string): Promise<ToolResult> {
+  const absolutePath = path.resolve(process.cwd(), filePath);
+
+  // Ensure directory exists
+  await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+  await fs.writeFile(absolutePath, content, 'utf-8');
+
+  return { success: true, result: `File written: ${filePath}` };
+}
+
+async function editFile(filePath: string, oldText: string, newText: string): Promise<ToolResult> {
+  const absolutePath = path.resolve(process.cwd(), filePath);
+  const content = await fs.readFile(absolutePath, 'utf-8');
+
+  if (!content.includes(oldText)) {
+    return { success: false, result: `Text not found in file: "${oldText.slice(0, 50)}..."` };
+  }
+
+  const newContent = content.replace(oldText, newText);
+  await fs.writeFile(absolutePath, newContent, 'utf-8');
+
+  return { success: true, result: `File edited: ${filePath}` };
+}
+
+async function listFiles(dirPath: string = '.', recursive: boolean = false): Promise<ToolResult> {
+  const absolutePath = path.resolve(process.cwd(), dirPath);
+
+  if (recursive) {
+    const files: string[] = [];
+    async function walk(dir: string) {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(absolutePath, fullPath);
+
+        // Skip common ignored directories
+        if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist') {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          files.push(relativePath + '/');
+          await walk(fullPath);
+        } else {
+          files.push(relativePath);
+        }
+      }
+    }
+    await walk(absolutePath);
+    return { success: true, result: files.join('\n') };
+  } else {
+    const entries = await fs.readdir(absolutePath, { withFileTypes: true });
+    const files = entries.map(e => e.name + (e.isDirectory() ? '/' : ''));
+    return { success: true, result: files.join('\n') };
+  }
+}
+
+async function searchFiles(pattern: string, dirPath: string = '.', filePattern?: string): Promise<ToolResult> {
+  const absolutePath = path.resolve(process.cwd(), dirPath);
+  const regex = new RegExp(pattern, 'gi');
+  const results: string[] = [];
+
+  async function searchDir(dir: string) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      // Skip common ignored directories
+      if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist') {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        await searchDir(fullPath);
+      } else {
+        // Check file pattern
+        if (filePattern) {
+          const ext = path.extname(entry.name);
+          const patternExt = filePattern.replace('*', '');
+          if (ext !== patternExt && !entry.name.match(filePattern.replace('*', '.*'))) {
+            continue;
+          }
+        }
+
+        try {
+          const content = await fs.readFile(fullPath, 'utf-8');
+          const lines = content.split('\n');
+
+          lines.forEach((line, index) => {
+            if (regex.test(line)) {
+              const relativePath = path.relative(absolutePath, fullPath);
+              results.push(`${relativePath}:${index + 1}: ${line.trim()}`);
+            }
+          });
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    }
+  }
+
+  await searchDir(absolutePath);
+
+  if (results.length === 0) {
+    return { success: true, result: 'No matches found.' };
+  }
+
+  return { success: true, result: results.slice(0, 100).join('\n') + (results.length > 100 ? `\n... and ${results.length - 100} more` : '') };
+}
+
+async function runCommand(command: string, cwd?: string): Promise<ToolResult> {
+  const workingDir = cwd ? path.resolve(process.cwd(), cwd) : process.cwd();
+
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd: workingDir,
+      maxBuffer: 1024 * 1024,
+      timeout: 60000
+    });
+
+    const output = stdout + (stderr ? `\nStderr:\n${stderr}` : '');
+    return { success: true, result: output || 'Command completed successfully.' };
+  } catch (error: any) {
+    return {
+      success: false,
+      result: error.stdout + (error.stderr ? `\nStderr:\n${error.stderr}` : '') || error.message
+    };
+  }
+}
+
+export function formatToolCall(name: string, args: Record<string, any>): string {
+  const labels: Record<string, string> = {
+    read_file: 'Reading file',
+    write_file: 'Writing file',
+    edit_file: 'Editing file',
+    list_files: 'Listing files',
+    search_files: 'Searching files',
+    run_command: 'Running command'
+  };
+
+  const label = labels[name] || name;
+  const argStr = Object.entries(args)
+    .map(([k, v]) => `${k}: ${typeof v === 'string' ? v.slice(0, 50) : v}`)
+    .join(', ');
+
+  return `${chalk.cyan('→')} ${chalk.bold(label)}: ${chalk.gray(argStr)}`;
+}

package/src/utils/api.ts

@@ -0,0 +1,213 @@
+import OpenAI from 'openai';
+import { config } from './config.js';
+
+interface Message {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+  name?: string;
+}
+
+interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+interface StreamCallbacks {
+  onContent: (content: string) => void;
+  onToolCall: (toolCall: ToolCall) => void;
+  onDone: (content: string, toolCalls?: ToolCall[]) => void;
+  onError: (error: Error) => void;
+}
+
+export const fileTools = [
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read the contents of a file',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'The file path to read' }
+        },
+        required: ['path']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: 'Write content to a file (creates or overwrites)',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'The file path to write to' },
+          content: { type: 'string', description: 'The content to write' }
+        },
+        required: ['path', 'content']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'edit_file',
+      description: 'Make targeted edits to a file by replacing specific text',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'The file path to edit' },
+          old_text: { type: 'string', description: 'The text to find and replace' },
+          new_text: { type: 'string', description: 'The replacement text' }
+        },
+        required: ['path', 'old_text', 'new_text']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_files',
+      description: 'List files in a directory',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'The directory path (default: current directory)' },
+          recursive: { type: 'boolean', description: 'Whether to list recursively' }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'search_files',
+      description: 'Search for text patterns across files',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'The search pattern (regex supported)' },
+          path: { type: 'string', description: 'Directory to search in (default: current)' },
+          file_pattern: { type: 'string', description: 'File glob pattern (e.g., "*.ts")' }
+        },
+        required: ['pattern']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_command',
+      description: 'Execute a shell command',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'The command to execute' },
+          cwd: { type: 'string', description: 'Working directory (default: current)' }
+        },
+        required: ['command']
+      }
+    }
+  }
+];
+
+export async function streamChat(
+  messages: Message[],
+  systemMessage: string,
+  model: string,
+  callbacks: StreamCallbacks
+): Promise<void> {
+  const apiKey = config.get('apiKey') as string;
+  const baseUrl = config.get('apiBaseUrl') as string || 'https://api.alia.onl';
+
+  const openai = new OpenAI({
+    apiKey,
+    baseURL: `${baseUrl}/v1`
+  });
+
+  const allMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
+    { role: 'system', content: systemMessage },
+    ...messages.map(m => {
+      if (m.role === 'tool') {
+        return { role: 'tool', tool_call_id: m.tool_call_id!, content: m.content };
+      } else if (m.tool_calls) {
+        return { role: 'assistant', content: m.content || '', tool_calls: m.tool_calls as any };
+      }
+      return { role: m.role, content: m.content };
+    })
+  ];
+
+  try {
+    const stream = await openai.chat.completions.create({
+      model,
+      messages: allMessages,
+      tools: fileTools as OpenAI.Chat.ChatCompletionTool[],
+      stream: true
+    });
+
+    let fullContent = '';
+    const toolCalls: ToolCall[] = [];
+    const toolCallsMap = new Map<number, ToolCall>();
+
+    for await (const chunk of stream) {
+      const delta = chunk.choices?.[0]?.delta;
+      if (!delta) continue;
+
+      if (delta.content) {
+        fullContent += delta.content;
+        callbacks.onContent(delta.content);
+      }
+
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const index = tc.index ?? 0;
+
+          if (!toolCallsMap.has(index)) {
+            const newToolCall: ToolCall = {
+              id: tc.id || '',
+              type: 'function',
+              function: {
+                name: tc.function?.name || '',
+                arguments: tc.function?.arguments || ''
+              }
+            };
+            toolCallsMap.set(index, newToolCall);
+            toolCalls.push(newToolCall);
+          } else {
+            const existingToolCall = toolCallsMap.get(index)!;
+            if (tc.function?.name) {
+              existingToolCall.function.name = tc.function.name;
+            }
+            if (tc.function?.arguments) {
+              existingToolCall.function.arguments += tc.function.arguments;
+            }
+          }
+        }
+      }
+    }
+
+    callbacks.onDone(fullContent, toolCalls.length > 0 ? toolCalls : undefined);
+  } catch (error: any) {
+    callbacks.onError(error);
+  }
+}
+
+export async function fetchModels(): Promise<any[]> {
+  const baseUrl = config.get('apiBaseUrl') || 'https://api.alia.onl';
+
+  try {
+    const response = await fetch(`${baseUrl}/v1/models?category=coding`);
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.data || [];
+  } catch {
+    return [];
+  }
+}

package/src/utils/config.ts

@@ -0,0 +1,70 @@
+import Conf from 'conf';
+
+interface Session {
+  id: string;
+  title: string;
+  messages: Array<{ role: string; content: string }>;
+  createdAt: number;
+  updatedAt: number;
+  cwd: string;
+}
+
+interface ConfigSchema {
+  apiKey: string;
+  apiBaseUrl: string;
+  defaultModel: string;
+  sessions: Session[];
+  currentSessionId: string | null;
+}
+
+export const config = new Conf<ConfigSchema>({
+  projectName: 'alia-codea-cli',
+  defaults: {
+    apiKey: '',
+    apiBaseUrl: 'https://api.alia.onl',
+    defaultModel: 'alia-v1-codea',
+    sessions: [],
+    currentSessionId: null,
+  },
+});
+
+export function saveSession(session: Session): void {
+  const sessions = config.get('sessions') || [];
+  const existingIndex = sessions.findIndex(s => s.id === session.id);
+
+  if (existingIndex >= 0) {
+    sessions[existingIndex] = session;
+  } else {
+    sessions.unshift(session);
+  }
+
+  // Keep only last 50 sessions
+  if (sessions.length > 50) {
+    sessions.splice(50);
+  }
+
+  config.set('sessions', sessions);
+}
+
+export function getSession(id: string): Session | undefined {
+  const sessions = config.get('sessions') || [];
+  return sessions.find(s => s.id === id);
+}
+
+export function getSessions(): Session[] {
+  return config.get('sessions') || [];
+}
+
+export function createSession(): Session {
+  const session: Session = {
+    id: Date.now().toString(),
+    title: 'New conversation',
+    messages: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    cwd: process.cwd(),
+  };
+  saveSession(session);
+  config.set('currentSessionId', session.id);
+  return session;
+}