arki 0.0.1

package/dist/index.js

@@ -0,0 +1,1003 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import * as readline from "readline";
+import * as fs5 from "fs";
+import * as path5 from "path";
+import * as os2 from "os";
+
+// src/config/config.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import { fileURLToPath } from "url";
+function getConfigPath() {
+  return path.join(os.homedir(), ".config", "arki", "config.json");
+}
+function getDefaultConfigPath() {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  return path.join(__dirname, "config.json");
+}
+var ConfigManager = class {
+  config;
+  loaded = false;
+  /**
+   * Load configuration (called at program startup)
+   */
+  async load() {
+    if (this.loaded) {
+      return this.config;
+    }
+    const configPath = getConfigPath();
+    try {
+      const content = await fs.readFile(configPath, "utf-8");
+      this.config = JSON.parse(content);
+    } catch {
+      const defaultContent = await fs.readFile(getDefaultConfigPath(), "utf-8");
+      this.config = JSON.parse(defaultContent);
+      const configDir = path.dirname(configPath);
+      await fs.mkdir(configDir, { recursive: true });
+      await fs.writeFile(configPath, defaultContent, "utf-8");
+    }
+    this.loadEnvApiKeys();
+    this.loaded = true;
+    return this.config;
+  }
+  /**
+   * Save configuration
+   */
+  async save() {
+    const configPath = getConfigPath();
+    const configToSave = { ...this.config };
+    if (this.config.apiKeys) {
+      configToSave.apiKeys = { ...this.config.apiKeys };
+      if (process.env.OPENAI_API_KEY && configToSave.apiKeys.openai === process.env.OPENAI_API_KEY) {
+        delete configToSave.apiKeys.openai;
+      }
+      if (process.env.ANTHROPIC_API_KEY && configToSave.apiKeys.anthropic === process.env.ANTHROPIC_API_KEY) {
+        delete configToSave.apiKeys.anthropic;
+      }
+    }
+    await fs.writeFile(configPath, JSON.stringify(configToSave, null, 2), "utf-8");
+  }
+  get() {
+    return this.config;
+  }
+  getApiKey(provider) {
+    return this.config.apiKeys?.[provider];
+  }
+  getAgentConfig(agentType) {
+    const agentConfig = this.config.agents[agentType];
+    if (!agentConfig) {
+      throw new Error(`Agent config not found for type: ${agentType}`);
+    }
+    return agentConfig;
+  }
+  loadEnvApiKeys() {
+    if (process.env.OPENAI_API_KEY) {
+      if (!this.config.apiKeys) this.config.apiKeys = {};
+      if (!this.config.apiKeys.openai) {
+        this.config.apiKeys.openai = process.env.OPENAI_API_KEY;
+      }
+    }
+    if (process.env.ANTHROPIC_API_KEY) {
+      if (!this.config.apiKeys) this.config.apiKeys = {};
+      if (!this.config.apiKeys.anthropic) {
+        this.config.apiKeys.anthropic = process.env.ANTHROPIC_API_KEY;
+      }
+    }
+    if (process.env.GOOGLE_API_KEY) {
+      if (!this.config.apiKeys) this.config.apiKeys = {};
+      if (!this.config.apiKeys.google) {
+        this.config.apiKeys.google = process.env.GOOGLE_API_KEY;
+      }
+    }
+  }
+};
+var config = new ConfigManager();
+
+// src/adapter/openai.ts
+import OpenAI from "openai";
+
+// src/adapter/Adapter.ts
+var TEMPERATURE = 0.2;
+var MAX_COMPLETION_TOKENS = 4096;
+var Adapter = class {
+  apiKey;
+  model;
+  /** Use Flex API (OpenAI) - low priority, low cost */
+  flex;
+  /** Reasoning effort (thinking mode) */
+  reasoningEffort;
+  /** Available tools list */
+  tools;
+  constructor(config2) {
+    this.apiKey = config2.apiKey;
+    this.model = config2.model;
+    this.flex = config2.flex;
+    this.reasoningEffort = config2.reasoningEffort;
+    this.tools = config2.tools;
+  }
+  getModel() {
+    return this.model;
+  }
+};
+
+// src/agent/Msg.ts
+var MsgType = /* @__PURE__ */ ((MsgType2) => {
+  MsgType2["System"] = "system";
+  MsgType2["User"] = "user";
+  MsgType2["AI"] = "ai";
+  MsgType2["ToolCall"] = "tool_call";
+  MsgType2["ToolResult"] = "tool_result";
+  return MsgType2;
+})(MsgType || {});
+var Msg = class {
+  timestamp;
+  content;
+  constructor(content) {
+    this.timestamp = Date.now();
+    this.content = content;
+  }
+};
+var SystemMsg = class extends Msg {
+  type = "system" /* System */;
+  constructor(content) {
+    super(content);
+  }
+};
+var UserMsg = class extends Msg {
+  type = "user" /* User */;
+  constructor(content) {
+    super(content);
+  }
+};
+var AIMsg = class extends Msg {
+  type = "ai" /* AI */;
+  constructor(content) {
+    super(content);
+  }
+};
+var ToolCallMsg = class extends Msg {
+  type = "tool_call" /* ToolCall */;
+  toolCalls;
+  constructor(content, toolCalls) {
+    super(content);
+    this.toolCalls = toolCalls;
+  }
+};
+var ToolResultMsg = class extends Msg {
+  type = "tool_result" /* ToolResult */;
+  toolName;
+  result;
+  isError;
+  constructor(toolName, result, isError) {
+    super("");
+    this.toolName = toolName;
+    this.result = result;
+    this.isError = isError;
+  }
+};
+
+// src/log/debug.ts
+var _debugMode = false;
+function isDebugMode() {
+  return _debugMode;
+}
+function setDebugMode(enabled) {
+  _debugMode = enabled;
+}
+function debug(category, message, data) {
+  if (!_debugMode) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+  const prefix = `${colors.gray}[${timestamp}]${colors.reset} ${colors.magenta}[DEBUG:${category}]${colors.reset}`;
+  console.log(`${prefix} ${colors.cyan}${message}${colors.reset}`);
+  if (data !== void 0) {
+    const dataStr = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+    const lines = dataStr.split("\n");
+    const maxLines = 20;
+    const truncated = lines.length > maxLines;
+    const displayLines = truncated ? lines.slice(-maxLines) : lines;
+    if (truncated) {
+      console.log(colors.dim + `    ... (${lines.length - maxLines} earlier lines)` + colors.reset);
+    }
+    console.log(colors.dim + displayLines.map((l) => `    ${l}`).join("\n") + colors.reset);
+  }
+}
+
+// src/log/log.ts
+function log(color, ...args) {
+  console.log(colors[color], ...args, colors.reset);
+}
+function info(message) {
+  console.log(`${colors.blue}\u2139${colors.reset} ${message}`);
+}
+function success(message) {
+  console.log(`${colors.green}\u2714${colors.reset} ${message}`);
+}
+function warn(message) {
+  console.log(`${colors.yellow}\u26A0${colors.reset} ${message}`);
+}
+function error(message) {
+  console.log(`${colors.red}\u2716${colors.reset} ${message}`);
+}
+
+// src/log/index.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  inverse: "\x1B[7m",
+  strikethrough: "\x1B[9m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+
+// src/adapter/openai.ts
+var OpenAIAdapter = class extends Adapter {
+  client;
+  constructor(config2) {
+    super(config2);
+    if (!this.apiKey) {
+      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable.");
+    }
+    this.client = new OpenAI({ apiKey: this.apiKey });
+  }
+  toOpenAIMessages(messages) {
+    const result = [];
+    let pendingIds = [];
+    for (const msg of messages) {
+      if (msg.type === "system" /* System */ || msg.type === "user" /* User */) {
+        result.push({ role: msg.type, content: msg.content });
+      } else if (msg.type === "ai" /* AI */) {
+        result.push({ role: "assistant", content: msg.content });
+      } else if (msg.type === "tool_call" /* ToolCall */) {
+        const toolCallMsg = msg;
+        pendingIds = toolCallMsg.toolCalls.map((_, i) => `call_${msg.timestamp}_${i}`);
+        result.push({
+          role: "assistant",
+          content: msg.content || null,
+          tool_calls: toolCallMsg.toolCalls.map((tc, i) => ({
+            id: pendingIds[i],
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+          }))
+        });
+      } else if (msg.type === "tool_result" /* ToolResult */) {
+        const toolResultMsg = msg;
+        result.push({
+          role: "tool",
+          tool_call_id: pendingIds.shift() || `call_${msg.timestamp}`,
+          content: toolResultMsg.isError ? `Error: ${toolResultMsg.result}` : toolResultMsg.result
+        });
+      }
+    }
+    return result;
+  }
+  getTools() {
+    return this.tools?.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: {
+          type: "object",
+          properties: t.parameters,
+          required: t.required.length > 0 ? t.required : void 0
+        }
+      }
+    }));
+  }
+  async chat(messages, onChunk) {
+    debug("API", `Requesting OpenAI (model: ${this.model}, messages: ${messages.length})`);
+    const openaiMessages = this.toOpenAIMessages(messages);
+    debug("API", "Sent prompt:", openaiMessages);
+    const startTime = Date.now();
+    const requestParams = {
+      model: this.model,
+      messages: openaiMessages,
+      tools: this.getTools(),
+      temperature: TEMPERATURE,
+      max_completion_tokens: MAX_COMPLETION_TOKENS,
+      stream: true,
+      stream_options: { include_usage: true },
+      service_tier: this.flex ? "flex" : void 0,
+      reasoning_effort: this.reasoningEffort
+    };
+    const stream = await this.client.chat.completions.create(requestParams);
+    let text = "";
+    const toolCalls = /* @__PURE__ */ new Map();
+    let usage;
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      if (delta?.content) {
+        text += delta.content;
+        onChunk?.(delta.content);
+      }
+      if (delta?.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const cur = toolCalls.get(tc.index) || { name: "", args: "" };
+          cur.name += tc.function?.name || "";
+          cur.args += tc.function?.arguments || "";
+          toolCalls.set(tc.index, cur);
+        }
+      }
+      if (chunk.usage) usage = chunk.usage;
+    }
+    const elapsed = Date.now() - startTime;
+    const cachedTokens = usage?.prompt_tokens_details?.cached_tokens;
+    const usageData = usage && {
+      promptTokens: usage.prompt_tokens,
+      completionTokens: usage.completion_tokens,
+      totalTokens: usage.total_tokens,
+      cachedTokens
+    };
+    if (toolCalls.size > 0) {
+      const calls = [...toolCalls.values()].map((tc) => ({
+        name: tc.name,
+        arguments: JSON.parse(tc.args || "{}")
+      }));
+      debug("API", `Completed (${elapsed}ms, tools: ${calls.map((t) => t.name).join(", ")})`);
+      return { message: new ToolCallMsg(text, calls), hasToolCalls: true, usage: usageData };
+    }
+    debug("API", `Completed (${elapsed}ms, tokens: ${usage?.total_tokens || "N/A"})`);
+    return { message: new AIMsg(text), hasToolCalls: false, usage: usageData };
+  }
+};
+
+// src/global.ts
+var workingDir = process.cwd();
+function setWorkingDir(dir) {
+  workingDir = dir;
+}
+var TOOLS = {};
+var adapter = null;
+function initAdapter() {
+  if (adapter) {
+    return;
+  }
+  const mainAgentConfig = config.getAgentConfig("main");
+  adapter = new OpenAIAdapter({
+    apiKey: config.getApiKey("openai") || "",
+    model: mainAgentConfig.model,
+    flex: mainAgentConfig.flex,
+    tools: Object.values(TOOLS)
+  });
+}
+async function init(cwd) {
+  workingDir = cwd || process.cwd();
+  await config.load();
+  initAdapter();
+}
+
+// src/tool/Tool.ts
+var Tool = class _Tool {
+  name;
+  description;
+  parameters;
+  required;
+  manual;
+  _execute;
+  constructor(config2) {
+    this.name = config2.name;
+    this.parameters = config2.parameters;
+    this.required = config2.required;
+    this._execute = config2.execute;
+    const { description, manual } = _Tool.parseManual(config2.manualContent);
+    this.description = description;
+    this.manual = manual;
+  }
+  /**
+   * Parse manual.md content
+   * First line format: "tool_name: description", extract description
+   * Remaining content is the manual
+   */
+  static parseManual(content) {
+    const lines = content.split("\n");
+    const firstLine = lines[0] || "";
+    let description = "";
+    const colonIndex = firstLine.indexOf(":");
+    if (colonIndex > 0) {
+      description = firstLine.slice(colonIndex + 1).trim();
+    }
+    const manual = lines.slice(1).join("\n").trim();
+    return { description, manual };
+  }
+  /**
+   * Execute tool (with error handling and logging)
+   */
+  async run(args) {
+    debug("Tool", `Starting tool execution: ${this.name}`, args);
+    const startTime = Date.now();
+    try {
+      const result = await this._execute(args);
+      const elapsed = Date.now() - startTime;
+      if (typeof result === "string") {
+        debug("Tool", `Tool execution successful: ${this.name} (elapsed: ${elapsed}ms, result length: ${result.length})`);
+        return new ToolResultMsg(this.name, result);
+      }
+      debug("Tool", `Tool execution completed: ${this.name} (elapsed: ${elapsed}ms, isError: ${result.isError || false})`);
+      return new ToolResultMsg(this.name, result.content, result.isError);
+    } catch (error2) {
+      const elapsed = Date.now() - startTime;
+      const errorMsg = error2 instanceof Error ? error2.message : String(error2);
+      debug("Tool", `Tool execution failed: ${this.name} (elapsed: ${elapsed}ms)`, errorMsg);
+      return new ToolResultMsg(this.name, `Error: ${errorMsg}`, true);
+    }
+  }
+};
+
+// src/tool/read_file/index.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+
+// src/tool/read_file/manual.md
+var manual_default = "read_file: Read the content of a specified file\n\n## Parameters\n\n- `path` (string, required): File path\n";
+
+// src/tool/read_file/index.ts
+TOOLS["read_file"] = new Tool({
+  name: "read_file",
+  parameters: {
+    path: { type: "string", description: "File path" }
+  },
+  required: ["path"],
+  manualContent: manual_default,
+  execute: async (args) => {
+    const filePath = args.path;
+    try {
+      const fullPath = path2.resolve(workingDir, filePath);
+      return await fs2.readFile(fullPath, "utf-8");
+    } catch (error2) {
+      return {
+        content: `Failed to read file: ${error2 instanceof Error ? error2.message : String(error2)}`,
+        isError: true
+      };
+    }
+  }
+});
+
+// src/tool/write_file/index.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+
+// src/tool/write_file/manual.md
+var manual_default2 = "write_file: Write content to a specified file, create the file if it doesn't exist\n\n## Parameters\n\n- `path` (string, required): File path\n- `content` (string, required): Content to write\n";
+
+// src/tool/write_file/index.ts
+TOOLS["write_file"] = new Tool({
+  name: "write_file",
+  parameters: {
+    path: { type: "string", description: "File path" },
+    content: { type: "string", description: "Content to write" }
+  },
+  required: ["path", "content"],
+  manualContent: manual_default2,
+  execute: async (args) => {
+    const filePath = args.path;
+    const content = args.content;
+    try {
+      const fullPath = path3.resolve(workingDir, filePath);
+      await fs3.mkdir(path3.dirname(fullPath), { recursive: true });
+      await fs3.writeFile(fullPath, content, "utf-8");
+      return `File written successfully: ${filePath}`;
+    } catch (error2) {
+      return {
+        content: `Failed to write file: ${error2 instanceof Error ? error2.message : String(error2)}`,
+        isError: true
+      };
+    }
+  }
+});
+
+// src/tool/list_directory/index.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+
+// src/tool/list_directory/manual.md
+var manual_default3 = "list_directory: List files and subdirectories in a specified directory\n\n## Parameters\n\n- `path` (string, optional): Directory path, defaults to current directory\n";
+
+// src/tool/list_directory/index.ts
+TOOLS["list_directory"] = new Tool({
+  name: "list_directory",
+  parameters: {
+    path: { type: "string", description: "Directory path" }
+  },
+  required: [],
+  manualContent: manual_default3,
+  execute: async (args) => {
+    const dirPath = args.path || ".";
+    try {
+      const fullPath = path4.resolve(workingDir, dirPath);
+      const entries = await fs4.readdir(fullPath, { withFileTypes: true });
+      const result = entries.map((entry) => {
+        const type = entry.isDirectory() ? "[DIR]" : "[FILE]";
+        return `${type} ${entry.name}`;
+      });
+      return result.join("\n") || "Directory is empty";
+    } catch (error2) {
+      return {
+        content: `Failed to list directory: ${error2 instanceof Error ? error2.message : String(error2)}`,
+        isError: true
+      };
+    }
+  }
+});
+
+// src/tool/run_command/manual.md
+var manual_default4 = "run_command: Execute shell command in the working directory\n\n## Parameters\n\n- `command` (string, required): Command to execute\n\n## Notes\n\n- Timeout is 30 seconds\n- Returns both stdout and stderr content\n";
+
+// src/tool/run_command/index.ts
+TOOLS["run_command"] = new Tool({
+  name: "run_command",
+  parameters: {
+    command: { type: "string", description: "Command to execute" }
+  },
+  required: ["command"],
+  manualContent: manual_default4,
+  execute: async (args) => {
+    const command = args.command;
+    try {
+      const { exec } = await import("child_process");
+      const { promisify } = await import("util");
+      const execAsync = promisify(exec);
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: workingDir,
+        timeout: 3e4
+      });
+      let result = "";
+      if (stdout) result += stdout;
+      if (stderr) result += `
+[stderr]
+${stderr}`;
+      return result.trim() || "Command executed successfully (no output)";
+    } catch (error2) {
+      return {
+        content: `Command execution failed: ${error2 instanceof Error ? error2.message : String(error2)}`,
+        isError: true
+      };
+    }
+  }
+});
+
+// src/tool/get_tool_info/manual.md
+var manual_default5 = "get_tool_info: View detailed usage instructions for a specified tool\n\n## Parameters\n\n- `tool_name` (string, required): Tool name to view\n\n";
+
+// src/tool/get_tool_info/index.ts
+TOOLS["get_tool_info"] = new Tool({
+  name: "get_tool_info",
+  parameters: {
+    tool_name: { type: "string", description: "Tool name to view" }
+  },
+  required: ["tool_name"],
+  manualContent: manual_default5,
+  execute: async (args) => {
+    const toolName = args.tool_name;
+    const foundTool = TOOLS[toolName];
+    if (!foundTool) {
+      const availableTools = Object.keys(TOOLS).join(", ");
+      return {
+        content: `Tool not found: ${toolName}
+Available tools: ${availableTools}`,
+        isError: true
+      };
+    }
+    return `# ${foundTool.name}
+
+${foundTool.description}
+
+${foundTool.manual}`;
+  }
+});
+
+// src/model/models.ts
+var MODELS = {
+  "gpt-5.2": {
+    name: "GPT-5.2",
+    provider: "openai",
+    capabilities: {
+      streaming: true,
+      vision: true,
+      contextWindow: 2e5
+    }
+  },
+  "gpt-5.1": {
+    name: "GPT-5.1",
+    provider: "openai",
+    capabilities: {
+      streaming: true,
+      vision: true,
+      contextWindow: 2e5
+    }
+  },
+  "gpt-5": {
+    name: "GPT-5",
+    provider: "openai",
+    capabilities: {
+      streaming: true,
+      vision: true,
+      contextWindow: 2e5
+    }
+  },
+  "gpt-5-nano": {
+    name: "GPT-5 Nano",
+    provider: "openai",
+    capabilities: {
+      streaming: true,
+      vision: true,
+      contextWindow: 128e3
+    }
+  }
+};
+
+// src/agent/Agent.ts
+var Agent = class {
+  config;
+  messages = [];
+  constructor(config2) {
+    this.config = config2;
+    this.messages = [...config2.messages];
+  }
+  /**
+   * Render template string, replacing {{variable}} style variables
+   */
+  static renderTemplate(template, variables) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
+      const value = variables[varName];
+      if (value !== void 0) {
+        return String(value);
+      }
+      console.warn(`Warning: Variable "{{${varName}}}" not found in template`);
+      return match;
+    });
+  }
+  async run(userInput) {
+    debug("Agent", `Received user input (length: ${userInput.length})`);
+    this.messages.push(new UserMsg(userInput));
+    const toolCallHistory = [];
+    let totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0, cachedTokens: 0 };
+    while (true) {
+      debug("Agent", `Starting conversation (message count: ${this.messages.length})`);
+      const response = await this.config.adapter.chat(this.messages, this.config.onStream);
+      if (response.usage) {
+        totalUsage.promptTokens += response.usage.promptTokens;
+        totalUsage.completionTokens += response.usage.completionTokens;
+        totalUsage.totalTokens += response.usage.totalTokens;
+        totalUsage.cachedTokens += response.usage.cachedTokens || 0;
+      }
+      this.messages.push(response.message);
+      if (!response.hasToolCalls) {
+        debug("Agent", `Conversation completed (total tokens: ${totalUsage.totalTokens})`);
+        const content = response.message.type === "ai" /* AI */ ? response.message.content : "";
+        return {
+          response: content,
+          toolCalls: toolCallHistory,
+          usage: totalUsage.totalTokens > 0 ? totalUsage : void 0
+        };
+      }
+      if (response.message.type !== "tool_call" /* ToolCall */) continue;
+      const toolCallMsg = response.message;
+      const toolCalls = toolCallMsg.toolCalls;
+      debug("Agent", `Received tool call request`, toolCalls.map((tc) => tc.name));
+      this.config.onToolCallMsg?.(toolCallMsg);
+      for (const tc of toolCalls) {
+        debug("Agent", `Executing tool: ${tc.name}`, tc.arguments);
+        const tool = TOOLS[tc.name];
+        const result = tool ? await tool.run(tc.arguments) : new ToolResultMsg(tc.name, `Unknown tool: ${tc.name}`, true);
+        debug("Agent", `Tool execution completed: ${tc.name}`, {
+          isError: result.isError,
+          contentLength: result.result.length
+        });
+        toolCallHistory.push({
+          name: tc.name,
+          arguments: tc.arguments,
+          result: result.result
+        });
+        this.config.onToolResult?.(tc.name, result.result);
+        this.messages.push(result);
+      }
+    }
+  }
+  reset() {
+    this.messages = [...this.config.messages];
+    return this;
+  }
+};
+
+// src/agent/main/colors.ts
+var tagNames = Object.keys(colors).filter((k) => k !== "reset").join("|");
+var tagRegex = new RegExp(`<(\\/?)(${tagNames})>`, "gi");
+function convertColorTags(str) {
+  return str.replace(tagRegex, (_, closing, tag) => {
+    return closing ? colors.reset : colors[tag.toLowerCase()] || "";
+  });
+}
+function createColorConverter() {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk;
+    const lastOpen = buffer.lastIndexOf("<");
+    if (lastOpen === -1) {
+      const out2 = convertColorTags(buffer);
+      buffer = "";
+      return out2;
+    }
+    if (buffer.indexOf(">", lastOpen) !== -1) {
+      const out2 = convertColorTags(buffer);
+      buffer = "";
+      return out2;
+    }
+    const out = convertColorTags(buffer.slice(0, lastOpen));
+    buffer = buffer.slice(lastOpen);
+    return out;
+  };
+}
+
+// src/agent/main/system.md
+var system_default = "You are Arki, a professional AI programming assistant. You work in the codebase directory `{{working_dir}}`.\n\n## Available Tools\n\n{{tools}}\n\nTools can be called multiple times at once. Make good use of this to improve efficiency.\nIf you need to understand the detailed usage of a tool, use the `get_tool_info` tool to view it.\n\n## Working Principles\n\n1. **Accuracy**: Before answering questions, use tools to view relevant code first. Don't base statements on assumptions. If you don't know something, just admit it - it's no big deal.\n2. **Safety**: Consider potential risks before executing commands.\n3. **Conciseness**: Keep answers brief and concise, avoid repetition and redundancy. Keep each response within 200 words unless the user requests detailed explanation.\n4. **Proactivity**: Actively suggest improvements when you find issues.\n\n## Response Style\n\n- Answer questions directly, avoid excessive pleasantries\n- Don't use emojis\n- Don't repeatedly ask about user needs, once is enough. Don't ask and answer yourself.\n\nThe user is talking to you via **CLI terminal**. **Do not** output Markdown. Use numbered lists for ordered lists, and \u2022 symbol for unordered lists.\nUse the following tags to format output:\n\n| Scenario | Format |\n|----------|--------|\n| Error/Danger | `<red>...</red>` |\n| Warning/Notice | `<yellow>...</yellow>` |\n| Success/Complete | `<green>...</green>` |\n| File path | `<cyan>...</cyan>` |\n| Code/Command | `<dim>...</dim>` |\n| Emphasis | `<bold>...</bold>` |\n\nTags can be combined, e.g., `<bold><red>Critical Error</red></bold>`\n\nPlease answer questions in the language the user is using, and flexibly use available tools to complete tasks.\n";
+
+// src/agent/main/main.ts
+function createMainAgent() {
+  if (!adapter) {
+    throw new Error("Adapter not initialized, please call init() first");
+  }
+  const toolDescriptions = Object.values(TOOLS).map((t) => `${t.name}: ${t.description}`).join("\n");
+  const systemInstruction = Agent.renderTemplate(system_default, {
+    working_dir: workingDir,
+    current_time: (/* @__PURE__ */ new Date()).toLocaleString(),
+    tools: toolDescriptions
+  });
+  const convertColor = createColorConverter();
+  const agent = new Agent({
+    adapter,
+    messages: [new SystemMsg(systemInstruction)],
+    onStream: (chunk) => {
+      process.stdout.write(convertColor(chunk));
+    },
+    onToolCallMsg: (msg) => {
+      for (const tc of msg.toolCalls) {
+        console.log();
+        log("yellow", `\u{1F527} Calling tool: ${tc.name}`);
+        log("dim", `   Arguments: ${JSON.stringify(tc.arguments)}`);
+      }
+    },
+    onToolResult: (_name, result) => {
+      const preview = result.length > 200 ? result.substring(0, 200) + "..." : result;
+      log("green", `   Result: ${preview.split("\n")[0]}`);
+      console.log();
+    }
+  });
+  return agent;
+}
+
+// package.json
+var package_default = {
+  name: "arki",
+  version: "0.0.1",
+  description: "AI Agent Programming Assistant",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    arki: "./bin/arki.js"
+  },
+  scripts: {
+    dev: "NODE_OPTIONS='--import ./register-md.mjs' tsx src/index.ts",
+    "dev:watch": "NODE_OPTIONS='--import ./register-md.mjs' tsx watch src/index.ts",
+    build: "tsup",
+    start: "node dist/index.js",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:e2e": "vitest run --testNamePattern='E2E'"
+  },
+  keywords: [
+    "ai",
+    "agent",
+    "cli",
+    "coding",
+    "assistant"
+  ],
+  author: "arki.moe",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/your-username/arki.git"
+  },
+  packageManager: "pnpm@10.15.1",
+  engines: {
+    node: ">=18"
+  },
+  files: [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  dependencies: {
+    openai: "^6.15.0"
+  },
+  devDependencies: {
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3",
+    vitest: "^4.0.16"
+  }
+};
+
+// src/index.ts
+function getConfigPath2() {
+  return path5.join(os2.homedir(), ".config", "arki", "config.json");
+}
+function resetConfig() {
+  const configPath = getConfigPath2();
+  if (fs5.existsSync(configPath)) {
+    fs5.unlinkSync(configPath);
+    console.log(`Configuration file deleted: ${configPath}`);
+    console.log("Default configuration will be used on next startup.");
+  } else {
+    console.log("Configuration file does not exist, no reset needed.");
+  }
+  process.exit(0);
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let targetDir = process.cwd();
+  let enableDebug = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-p" && args[i + 1]) {
+      targetDir = args[i + 1];
+      i++;
+    } else if (args[i] === "--debug" || args[i] === "-d") {
+      enableDebug = true;
+    } else if (args[i] === "--reset") {
+      resetConfig();
+    } else if (args[i] === "--help" || args[i] === "-h") {
+      console.log(`
+Usage: arki [options]
+
+Options:
+  -p <path>      Specify working directory
+  --debug, -d    Enable debug mode, show detailed logs
+  --reset        Reset configuration to factory defaults
+  --help, -h     Show help information
+`);
+      process.exit(0);
+    }
+  }
+  return { targetDir, enableDebug };
+}
+async function main() {
+  const { targetDir, enableDebug } = parseArgs();
+  if (enableDebug) {
+    setDebugMode(true);
+    debug("Init", "Debug mode enabled");
+  }
+  await init(targetDir);
+  const mainAgentConfig = config.getAgentConfig("main");
+  const model = MODELS[mainAgentConfig.model];
+  console.log();
+  log("cyan", `Arki AI Agent v${package_default.version}`);
+  console.log();
+  log("dim", `Model: ${mainAgentConfig.model}${model ? ` (${model.name})` : ""}`);
+  log("dim", `Working directory: ${workingDir}`);
+  if (isDebugMode()) {
+    log("yellow", `\u{1F41B} Debug mode enabled`);
+  }
+  console.log();
+  log("dim", `Loaded ${Object.keys(TOOLS).length} tools`);
+  if (isDebugMode()) {
+    debug("Init", "Loaded tools", Object.keys(TOOLS));
+    debug("Init", "Agent config", mainAgentConfig);
+  }
+  console.log();
+  const agent = createMainAgent();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  log("blue", "Enter your question and press Enter to send. Type /exit or /quit to exit.");
+  log("blue", "Type /clear to clear conversation history.");
+  console.log();
+  const prompt = () => {
+    rl.question(`${colors.green}> ${colors.reset}`, async (input) => {
+      const trimmed = input.trim();
+      if (trimmed === "/exit" || trimmed === "/quit") {
+        log("cyan", "Goodbye!");
+        rl.close();
+        process.exit(0);
+      }
+      if (trimmed === "/clear") {
+        agent.reset();
+        log("yellow", "Conversation history cleared");
+        console.log();
+        prompt();
+        return;
+      }
+      if (trimmed === "/help") {
+        console.log();
+        log("cyan", "Available commands:");
+        log("dim", "  /exit, /quit  - Exit program");
+        log("dim", "  /clear        - Clear conversation history");
+        log("dim", "  /debug        - Toggle debug mode");
+        log("dim", "  /help         - Show help");
+        console.log();
+        prompt();
+        return;
+      }
+      if (trimmed === "/debug") {
+        setDebugMode(!isDebugMode());
+        log("yellow", `Debug mode ${isDebugMode() ? "enabled \u{1F41B}" : "disabled"}`);
+        console.log();
+        prompt();
+        return;
+      }
+      if (!trimmed) {
+        prompt();
+        return;
+      }
+      console.log();
+      try {
+        const result = await agent.run(trimmed);
+        console.log();
+        if (result.usage) {
+          const contextLimit = model?.capabilities.contextWindow || "N/A";
+          log(
+            "dim",
+            `[Tokens: ${result.usage.totalTokens} (prompt: ${result.usage.promptTokens}, cached: ${result.usage.cachedTokens || 0}, limit: ${contextLimit})]`
+          );
+        }
+        console.log();
+      } catch (error2) {
+        log("red", `Error: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        console.log();
+      }
+      prompt();
+    });
+  };
+  prompt();
+}
+main().catch((error2) => {
+  console.error("Fatal error:", error2);
+  process.exit(1);
+});
+export {
+  AIMsg,
+  Adapter,
+  Agent,
+  MAX_COMPLETION_TOKENS,
+  MODELS,
+  Msg,
+  MsgType,
+  OpenAIAdapter,
+  SystemMsg,
+  TEMPERATURE,
+  TOOLS,
+  Tool,
+  ToolCallMsg,
+  ToolResultMsg,
+  UserMsg,
+  adapter,
+  colors,
+  config,
+  debug,
+  error,
+  info,
+  init,
+  isDebugMode,
+  log,
+  setDebugMode,
+  setWorkingDir,
+  success,
+  warn,
+  workingDir
+};