@alia-codea/cli 1.1.0 → 2.0.0

package/src/utils/conversation.ts

@@ -0,0 +1,141 @@
+import { streamChat } from './api.js';
+import { executeTool } from '../tools/executor.js';
+import { ApprovalMode, needsApproval } from './approval.js';
+
+export interface Message {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface ToolExecution {
+  id: string;
+  tool: string;
+  args: Record<string, any>;
+  result?: string;
+  success?: boolean;
+  approved?: boolean;
+}
+
+export type ConversationEvent =
+  | { type: 'thinking' }
+  | { type: 'content'; text: string }
+  | { type: 'tool_start'; execution: ToolExecution }
+  | { type: 'approval_needed'; execution: ToolExecution; resolve: (approved: boolean) => void }
+  | { type: 'tool_done'; execution: ToolExecution }
+  | { type: 'done'; content: string }
+  | { type: 'error'; message: string };
+
+export interface ConversationOptions {
+  messages: Message[];
+  systemMessage: string;
+  model: string;
+  approvalMode: ApprovalMode;
+  onEvent: (event: ConversationEvent) => void;
+  requestApproval: (execution: ToolExecution) => Promise<boolean>;
+  isActive: () => boolean;
+}
+
+export async function processConversation(opts: ConversationOptions): Promise<void> {
+  const { messages, systemMessage, model, approvalMode, onEvent, requestApproval, isActive } = opts;
+
+  while (isActive()) {
+    let fullContent = '';
+    let toolCalls: ToolCall[] | undefined;
+
+    onEvent({ type: 'thinking' });
+
+    try {
+      await streamChat(messages, systemMessage, model, {
+        onContent: (content) => {
+          if (!isActive()) return;
+          fullContent += content;
+          onEvent({ type: 'content', text: content });
+        },
+        onToolCall: () => {},
+        onDone: (_content, tcs) => {
+          toolCalls = tcs;
+        },
+        onError: (error) => {
+          onEvent({ type: 'error', message: error.message });
+        },
+      });
+    } catch (error: any) {
+      onEvent({ type: 'error', message: error.message });
+      break;
+    }
+
+    if (!isActive()) break;
+
+    if (toolCalls && toolCalls.length > 0) {
+      messages.push({
+        role: 'assistant',
+        content: fullContent,
+        tool_calls: toolCalls,
+      });
+
+      for (const tc of toolCalls) {
+        if (!isActive()) break;
+
+        const args = JSON.parse(tc.function.arguments);
+        const execution: ToolExecution = {
+          id: tc.id,
+          tool: tc.function.name,
+          args,
+        };
+
+        onEvent({ type: 'tool_start', execution });
+
+        // Check approval
+        if (needsApproval(tc.function.name, approvalMode)) {
+          const approved = await requestApproval(execution);
+          if (!approved) {
+            execution.approved = false;
+            execution.success = false;
+            execution.result = 'User declined this action.';
+            messages.push({
+              role: 'tool',
+              tool_call_id: tc.id,
+              content: 'User declined this action.',
+            });
+            onEvent({ type: 'tool_done', execution });
+            continue;
+          }
+          execution.approved = true;
+        } else {
+          execution.approved = true;
+        }
+
+        const result = await executeTool(tc.function.name, args);
+        execution.result = result.result;
+        execution.success = result.success;
+
+        messages.push({
+          role: 'tool',
+          tool_call_id: tc.id,
+          content: result.result,
+        });
+
+        onEvent({ type: 'tool_done', execution });
+      }
+
+      continue;
+    } else {
+      if (fullContent) {
+        messages.push({ role: 'assistant', content: fullContent });
+      }
+      onEvent({ type: 'done', content: fullContent });
+      break;
+    }
+  }
+}

package/dist/api-X2G5QROW.js

@@ -1,10 +0,0 @@
-import {
-  fetchModels,
-  fileTools,
-  streamChat
-} from "./chunk-SVPL4GNV.js";
-export {
-  fetchModels,
-  fileTools,
-  streamChat
-};

package/dist/chunk-SVPL4GNV.js

@@ -1,230 +0,0 @@
-// src/utils/api.ts
-import OpenAI from "openai";
-
-// src/utils/config.ts
-import Conf from "conf";
-var config = new Conf({
-  projectName: "alia-codea-cli",
-  defaults: {
-    apiKey: "",
-    apiBaseUrl: "https://api.alia.onl",
-    defaultModel: "alia-v1-codea",
-    sessions: [],
-    currentSessionId: null
-  }
-});
-function saveSession(session) {
-  const sessions = config.get("sessions") || [];
-  const existingIndex = sessions.findIndex((s) => s.id === session.id);
-  if (existingIndex >= 0) {
-    sessions[existingIndex] = session;
-  } else {
-    sessions.unshift(session);
-  }
-  if (sessions.length > 50) {
-    sessions.splice(50);
-  }
-  config.set("sessions", sessions);
-}
-function getSession(id) {
-  const sessions = config.get("sessions") || [];
-  return sessions.find((s) => s.id === id);
-}
-function getSessions() {
-  return config.get("sessions") || [];
-}
-function createSession() {
-  const 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;
-}
-
-// src/utils/api.ts
-var 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"]
-      }
-    }
-  }
-];
-async function streamChat(messages, systemMessage, model, callbacks) {
-  const apiKey = config.get("apiKey");
-  const baseUrl = config.get("apiBaseUrl") || "https://api.alia.onl";
-  const openai = new OpenAI({
-    apiKey,
-    baseURL: `${baseUrl}/v1`
-  });
-  const allMessages = [
-    { 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 };
-      }
-      return { role: m.role, content: m.content };
-    })
-  ];
-  try {
-    const stream = await openai.chat.completions.create({
-      model,
-      messages: allMessages,
-      tools: fileTools,
-      stream: true
-    });
-    let fullContent = "";
-    const toolCalls = [];
-    const toolCallsMap = /* @__PURE__ */ new Map();
-    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 = {
-              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 : void 0);
-  } catch (error) {
-    callbacks.onError(error);
-  }
-}
-async function fetchModels() {
-  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 [];
-  }
-}
-
-export {
-  config,
-  saveSession,
-  getSession,
-  getSessions,
-  createSession,
-  fileTools,
-  streamChat,
-  fetchModels
-};

package/dist/index.d.ts

@@ -1 +0,0 @@
-#!/usr/bin/env node

package/src/utils/ui.ts

@@ -1,153 +0,0 @@
-import chalk from 'chalk';
-import * as readline from 'readline';
-
-// Gradient colors for the banner (cyan to magenta)
-const gradientColors = [
-  '#00d4ff', '#00c4ff', '#00b4ff', '#00a4ff',
-  '#4094ff', '#8084ff', '#c074ff', '#ff64ff'
-];
-
-function hexToRgb(hex: string): [number, number, number] {
-  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-  return result
-    ? [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)]
-    : [255, 255, 255];
-}
-
-function colorize(text: string, colorIndex: number, totalColors: number): string {
-  const ratio = colorIndex / totalColors;
-  const startColor = hexToRgb(gradientColors[0]);
-  const endColor = hexToRgb(gradientColors[gradientColors.length - 1]);
-
-  const r = Math.round(startColor[0] + ratio * (endColor[0] - startColor[0]));
-  const g = Math.round(startColor[1] + ratio * (endColor[1] - startColor[1]));
-  const b = Math.round(startColor[2] + ratio * (endColor[2] - startColor[2]));
-
-  return chalk.rgb(r, g, b)(text);
-}
-
-// ASCII art banner with gradient
-export function printBanner(): void {
-  const banner = [
-    '   ██████╗ ██████╗ ██████╗ ███████╗ █████╗ ',
-    '  ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗',
-    '  ██║     ██║   ██║██║  ██║█████╗  ███████║',
-    '  ██║     ██║   ██║██║  ██║██╔══╝  ██╔══██║',
-    '  ╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║',
-    '   ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝',
-  ];
-
-  console.log();
-  banner.forEach((line, i) => {
-    let coloredLine = '';
-    for (let j = 0; j < line.length; j++) {
-      coloredLine += colorize(line[j], j, line.length);
-    }
-    console.log(coloredLine);
-  });
-  console.log(chalk.gray('  by Alia'));
-  console.log();
-}
-
-export function printTips(): void {
-  console.log(chalk.white('Tips for getting started:'));
-  console.log(chalk.gray('1. Ask questions, edit files, or run commands.'));
-  console.log(chalk.gray('2. Be specific for the best results.'));
-  console.log(chalk.gray('3. ') + chalk.cyan('/help') + chalk.gray(' for more information.'));
-  console.log();
-}
-
-export function printPrompt(): void {
-  process.stdout.write(chalk.cyan('❯ '));
-}
-
-export function printToolExecution(tool: string, description: string): void {
-  const boxWidth = Math.min(process.stdout.columns || 80, 80);
-  const content = `${chalk.bold(tool)} ${description}`;
-  const paddedContent = ` ← ${content} `.padEnd(boxWidth - 4);
-
-  console.log();
-  console.log(chalk.gray('┌' + '─'.repeat(boxWidth - 2) + '┐'));
-  console.log(chalk.gray('│') + paddedContent + chalk.gray('│'));
-  console.log(chalk.gray('└' + '─'.repeat(boxWidth - 2) + '┘'));
-}
-
-export function printToolResult(success: boolean, result: string): void {
-  const status = success ? chalk.green('✓') : chalk.red('✗');
-  const preview = result.slice(0, 100).replace(/\n/g, ' ');
-  console.log(`  ${status} ${chalk.gray(preview)}${result.length > 100 ? '...' : ''}`);
-  console.log();
-}
-
-let statusInterval: NodeJS.Timeout | null = null;
-let startTime: number = 0;
-
-export function showThinkingStatus(message: string): void {
-  startTime = Date.now();
-  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-  let frameIndex = 0;
-
-  statusInterval = setInterval(() => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-    const frame = frames[frameIndex % frames.length];
-    frameIndex++;
-
-    readline.clearLine(process.stdout, 0);
-    readline.cursorTo(process.stdout, 0);
-    process.stdout.write(
-      chalk.cyan(frame) + ' ' +
-      chalk.bold(message) +
-      chalk.gray(` (esc to cancel, ${elapsed}s)`)
-    );
-  }, 80);
-}
-
-export function hideThinkingStatus(): void {
-  if (statusInterval) {
-    clearInterval(statusInterval);
-    statusInterval = null;
-    readline.clearLine(process.stdout, 0);
-    readline.cursorTo(process.stdout, 0);
-  }
-}
-
-export function printStatusBar(cwd: string, model: string, contextPercent: number): void {
-  const width = process.stdout.columns || 80;
-  const cwdPart = chalk.cyan(shortenPath(cwd));
-  const modelPart = chalk.magenta(`${model} (${contextPercent}% context left)`);
-
-  const padding = width - stripAnsi(cwdPart).length - stripAnsi(modelPart).length - 4;
-  const spacer = ' '.repeat(Math.max(padding, 2));
-
-  console.log();
-  console.log(chalk.gray('─'.repeat(width)));
-  console.log(`${cwdPart}${spacer}${modelPart}`);
-}
-
-function shortenPath(p: string): string {
-  const home = process.env.HOME || '';
-  if (p.startsWith(home)) {
-    return '~' + p.slice(home.length);
-  }
-  return p;
-}
-
-function stripAnsi(str: string): string {
-  return str.replace(/\x1b\[[0-9;]*m/g, '');
-}
-
-export function printAssistantPrefix(): void {
-  process.stdout.write(chalk.magenta('✦ '));
-}
-
-export function printError(message: string): void {
-  console.log(chalk.red('✗ Error: ') + message);
-}
-
-export function printSuccess(message: string): void {
-  console.log(chalk.green('✓ ') + message);
-}
-
-export function printInfo(message: string): void {
-  console.log(chalk.blue('ℹ ') + message);
-}