arki 0.0.5 → 0.0.6

package/dist/index.js

@@ -1,191 +1,267 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// 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";
+// src/fs/paths.ts
+import os from "os";
+import path from "path";
 import { fileURLToPath } from "url";
-function getConfigPath() {
-  return path.join(os.homedir(), ".config", "arki", "config.json");
+function getOSName() {
+  const platform = os.platform();
+  switch (platform) {
+    case "win32":
+      return "windows";
+    case "darwin":
+      return "mac";
+    case "linux":
+      return "linux";
+    default:
+      return "other";
+  }
+}
+function setWorkingDir(dir) {
+  workingDir = dir;
 }
-function getDefaultConfigPath() {
+function getGlobalConfigDir() {
+  if (OS.name === "windows") {
+    return path.join(
+      process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"),
+      "arki"
+    );
+  }
+  return path.join(os.homedir(), ".config", "arki");
+}
+function getPackageDir(relativePath) {
   const __dirname = path.dirname(fileURLToPath(import.meta.url));
-  return path.join(__dirname, "config.json");
+  return path.join(__dirname, "..", relativePath);
 }
-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;
+var OS, workingDir, PATHS;
+var init_paths = __esm({
+  "src/fs/paths.ts"() {
+    "use strict";
+    OS = {
+      name: getOSName(),
+      version: os.release()
+    };
+    workingDir = process.cwd();
+    PATHS = {
+      /** Global config directory (~/.config/arki or %APPDATA%\arki) */
+      globalConfig: getGlobalConfigDir(),
+      /** Project config directory (.arki/) - returns path based on current workingDir */
+      get projectConfig() {
+        return path.join(workingDir, ".arki");
+      },
+      /** Package's global config template directory */
+      globalTemplate: getPackageDir("config/arki"),
+      /** Package's project config template directory */
+      projectTemplate: getPackageDir("config/.arki")
+    };
   }
-  /**
-   * 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");
+});
+
+// src/fs/file.ts
+import * as fs from "fs/promises";
+async function fileExists(filePath) {
+  try {
+    const stat3 = await fs.stat(filePath);
+    return stat3.isFile();
+  } catch {
+    return false;
   }
-  get() {
-    return this.config;
+}
+async function readJsonFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
   }
-  getApiKey(provider) {
-    return this.config.apiKeys?.[provider];
+}
+async function writeJsonFile(filePath, data) {
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+async function readFile2(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
   }
-  getAgentConfig(agentType) {
-    const agentConfig = this.config.agents[agentType];
-    if (!agentConfig) {
-      throw new Error(`Agent config not found for type: ${agentType}`);
-    }
-    return agentConfig;
+}
+async function writeFile2(filePath, content) {
+  await fs.writeFile(filePath, content, "utf-8");
+}
+var init_file = __esm({
+  "src/fs/file.ts"() {
+    "use strict";
   }
-  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;
-      }
+});
+
+// src/fs/dir.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+async function copyDir(src, dest) {
+  await fs2.mkdir(dest, { recursive: true });
+  const entries = await fs2.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs2.copyFile(srcPath, destPath);
     }
   }
-};
-var config = new ConfigManager();
+}
+async function dirExists(dirPath) {
+  try {
+    const stat3 = await fs2.stat(dirPath);
+    return stat3.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function mkdir2(dirPath) {
+  await fs2.mkdir(dirPath, { recursive: true });
+}
+var init_dir = __esm({
+  "src/fs/dir.ts"() {
+    "use strict";
+  }
+});
 
-// src/adapter/openai.ts
-import OpenAI from "openai";
+// src/fs/index.ts
+var fs_exports = {};
+__export(fs_exports, {
+  OS: () => OS,
+  PATHS: () => PATHS,
+  copyDir: () => copyDir,
+  dirExists: () => dirExists,
+  fileExists: () => fileExists,
+  mkdir: () => mkdir2,
+  readFile: () => readFile2,
+  readJsonFile: () => readJsonFile,
+  setWorkingDir: () => setWorkingDir,
+  workingDir: () => workingDir,
+  writeFile: () => writeFile2,
+  writeJsonFile: () => writeJsonFile
+});
+var init_fs = __esm({
+  "src/fs/index.ts"() {
+    "use strict";
+    init_paths();
+    init_file();
+    init_dir();
+  }
+});
 
 // 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;
+var TEMPERATURE, MAX_COMPLETION_TOKENS, Adapter;
+var init_Adapter = __esm({
+  "src/adapter/Adapter.ts"() {
+    "use strict";
+    TEMPERATURE = 0.2;
+    MAX_COMPLETION_TOKENS = 4096;
+    Adapter = class {
+      apiKey;
+      model;
+      /** Use Flex API (OpenAI) - low priority, low cost */
+      flex;
+      /** Reasoning effort (thinking mode) */
+      reasoningEffort;
+      /** Available tools list */
+      tools;
+      constructor(config) {
+        this.apiKey = config.apiKey;
+        this.model = config.model;
+        this.flex = config.flex;
+        this.reasoningEffort = config.reasoningEffort;
+        this.tools = config.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 _ToolResultMsg extends Msg {
-  type = "tool_result" /* ToolResult */;
-  toolResults;
-  constructor(toolResults) {
-    super("");
-    this.toolResults = toolResults;
-  }
-  /** Helper: create from single result */
-  static single(toolName, result, isError) {
-    return new _ToolResultMsg([{ toolName, result, isError }]);
+var MsgType, Msg, SystemMsg, UserMsg, AIMsg, ToolCallMsg, ToolResultMsg;
+var init_Msg = __esm({
+  "src/agent/Msg.ts"() {
+    "use strict";
+    MsgType = /* @__PURE__ */ ((MsgType2) => {
+      MsgType2["System"] = "system";
+      MsgType2["User"] = "user";
+      MsgType2["AI"] = "ai";
+      MsgType2["ToolCall"] = "tool_call";
+      MsgType2["ToolResult"] = "tool_result";
+      return MsgType2;
+    })(MsgType || {});
+    Msg = class {
+      timestamp;
+      content;
+      constructor(content) {
+        this.timestamp = Date.now();
+        this.content = content;
+      }
+    };
+    SystemMsg = class extends Msg {
+      type = "system" /* System */;
+      constructor(content) {
+        super(content);
+      }
+    };
+    UserMsg = class extends Msg {
+      type = "user" /* User */;
+      constructor(content) {
+        super(content);
+      }
+    };
+    AIMsg = class extends Msg {
+      type = "ai" /* AI */;
+      constructor(content) {
+        super(content);
+      }
+    };
+    ToolCallMsg = class extends Msg {
+      type = "tool_call" /* ToolCall */;
+      toolCalls;
+      constructor(content, toolCalls) {
+        super(content);
+        this.toolCalls = toolCalls;
+      }
+    };
+    ToolResultMsg = class _ToolResultMsg extends Msg {
+      type = "tool_result" /* ToolResult */;
+      toolResults;
+      constructor(toolResults) {
+        super("");
+        this.toolResults = toolResults;
+      }
+      /** Helper: create from single result */
+      static single(toolName, result, isError) {
+        return new _ToolResultMsg([{ toolName, result, isError }]);
+      }
+    };
   }
-};
+});
 
 // src/log/log.ts
 function getTimestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
 }
+function print(message) {
+  console.log(convertColorTags(message));
+}
 function log(message) {
-  const ts = `<gray>[${getTimestamp()}]</gray>`;
-  console.log(convertColorTags(`${ts} ${message}`));
+  print(`<gray>[${getTimestamp()}]</gray> ${message}`);
 }
 function info(message) {
   log(`<blue>[INFO]</blue> ${message}`);
@@ -199,9 +275,14 @@ function warn(message) {
 function error(message) {
   log(`<red>[ERROR]</red> ${message}`);
 }
+var init_log = __esm({
+  "src/log/log.ts"() {
+    "use strict";
+    init_log2();
+  }
+});
 
 // src/log/debug.ts
-var _debugMode = false;
 function isDebugMode() {
   return _debugMode;
 }
@@ -219,29 +300,19 @@ function debug(category, message, data) {
   const dataStr = data !== void 0 ? ` <dim>${formatData(data)}</dim>` : "";
   log(`<magenta>[${category}]</magenta> <cyan>${message}</cyan>${dataStr}`);
 }
+var _debugMode;
+var init_debug = __esm({
+  "src/log/debug.ts"() {
+    "use strict";
+    init_log();
+    _debugMode = false;
+  }
+});
 
 // src/log/index.ts
-var colors2 = {
-  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"
-};
-var tagNames = Object.keys(colors2).filter((k) => k !== "reset").join("|");
-var tagRegex = new RegExp(`<(\\/?)(${tagNames})>`, "gi");
 function convertColorTags(str) {
   return str.replace(tagRegex, (_, closing, tag) => {
-    return closing ? colors2.reset : colors2[tag.toLowerCase()] || "";
+    return closing ? colors.reset : colors[tag.toLowerCase()] || "";
   });
 }
 function createColorConverter() {
@@ -264,147 +335,399 @@ function createColorConverter() {
     return out;
   };
 }
+var colors, tagNames, tagRegex;
+var init_log2 = __esm({
+  "src/log/index.ts"() {
+    "use strict";
+    init_debug();
+    init_log();
+    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"
+    };
+    tagNames = Object.keys(colors).filter((k) => k !== "reset").join("|");
+    tagRegex = new RegExp(`<(\\/?)(${tagNames})>`, "gi");
+  }
+});
 
 // 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;
-        for (const tr of toolResultMsg.toolResults) {
-          result.push({
-            role: "tool",
-            tool_call_id: pendingIds.shift() || `call_${msg.timestamp}`,
-            content: tr.isError ? `Error: ${tr.result}` : tr.result
-          });
+import OpenAI from "openai";
+var OpenAIAdapter;
+var init_openai = __esm({
+  "src/adapter/openai.ts"() {
+    "use strict";
+    init_Adapter();
+    init_Msg();
+    init_log2();
+    OpenAIAdapter = class extends Adapter {
+      client;
+      constructor(config) {
+        super(config);
+        if (!this.apiKey) {
+          throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable.");
         }
+        this.client = new OpenAI({ apiKey: this.apiKey });
       }
-    }
-    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
+      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;
+            for (const tr of toolResultMsg.toolResults) {
+              result.push({
+                role: "tool",
+                tool_call_id: pendingIds.shift() || `call_${msg.timestamp}`,
+                content: tr.isError ? `Error: ${tr.result}` : tr.result
+              });
+            }
+          }
         }
+        return result;
       }
-    }));
-  }
-  async chat(messages, onChunk) {
-    debug("API", `Requesting OpenAI (model: ${this.model}, messages: ${messages.length})`);
-    const openaiMessages = this.toOpenAIMessages(messages);
-    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);
+      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
+            }
+          }
+        }));
       }
-      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);
+      async chat(messages, onChunk) {
+        debug("API", `Requesting OpenAI (model: ${this.model}, messages: ${messages.length})`);
+        const openaiMessages = this.toOpenAIMessages(messages);
+        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 };
       }
-      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 };
+  }
+});
+
+// src/init/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  getAgentConfig: () => getAgentConfig,
+  getApiKey: () => getApiKey,
+  getConfig: () => getConfig,
+  loadConfigs: () => loadConfigs,
+  saveConfig: () => saveConfig
+});
+import * as path3 from "path";
+function deepMerge(base, override) {
+  const result = {
+    ...base,
+    agents: { ...base.agents }
+  };
+  if (override.apiKeys) {
+    result.apiKeys = { ...base.apiKeys, ...override.apiKeys };
+  }
+  if (override.agents) {
+    for (const key of Object.keys(override.agents)) {
+      const overrideAgent = override.agents[key];
+      if (overrideAgent) {
+        result.agents[key] = { ...result.agents[key], ...overrideAgent };
+      }
     }
-    debug("API", `Completed (${elapsed}ms, tokens: ${usage?.total_tokens || "N/A"})`);
-    return { message: new AIMsg(text), hasToolCalls: false, usage: usageData };
   }
-};
+  return result;
+}
+function loadEnvApiKeys(config) {
+  if (process.env.OPENAI_API_KEY) {
+    if (!config.apiKeys) config.apiKeys = {};
+    if (!config.apiKeys.openai) {
+      config.apiKeys.openai = process.env.OPENAI_API_KEY;
+    }
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    if (!config.apiKeys) config.apiKeys = {};
+    if (!config.apiKeys.anthropic) {
+      config.apiKeys.anthropic = process.env.ANTHROPIC_API_KEY;
+    }
+  }
+  if (process.env.GOOGLE_API_KEY) {
+    if (!config.apiKeys) config.apiKeys = {};
+    if (!config.apiKeys.google) {
+      config.apiKeys.google = process.env.GOOGLE_API_KEY;
+    }
+  }
+}
+async function loadConfigs() {
+  if (mergedConfig) {
+    return mergedConfig;
+  }
+  const globalConfigPath = path3.join(PATHS.globalConfig, "config.json");
+  const globalConfig = await readJsonFile(globalConfigPath);
+  if (!globalConfig) {
+    throw new Error(`Failed to load global config: ${globalConfigPath}`);
+  }
+  const projectConfigPath = path3.join(PATHS.projectConfig, "config.json");
+  const projectConfig = await readJsonFile(projectConfigPath);
+  if (projectConfig) {
+    mergedConfig = deepMerge(globalConfig, projectConfig);
+  } else {
+    mergedConfig = globalConfig;
+  }
+  loadEnvApiKeys(mergedConfig);
+  return mergedConfig;
+}
+function getConfig() {
+  if (!mergedConfig) {
+    throw new Error("Config not loaded yet. Please call loadConfigs() first.");
+  }
+  return mergedConfig;
+}
+function getApiKey(provider) {
+  return getConfig().apiKeys?.[provider];
+}
+function getAgentConfig(agentType) {
+  const agentConfig = getConfig().agents[agentType];
+  if (!agentConfig) {
+    throw new Error(`Agent config not found: ${agentType}`);
+  }
+  return agentConfig;
+}
+async function saveConfig() {
+  const config = getConfig();
+  const configPath = path3.join(PATHS.globalConfig, "config.json");
+  const configToSave = { ...config };
+  if (config.apiKeys) {
+    configToSave.apiKeys = { ...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;
+    }
+    if (process.env.GOOGLE_API_KEY && configToSave.apiKeys.google === process.env.GOOGLE_API_KEY) {
+      delete configToSave.apiKeys.google;
+    }
+  }
+  await writeJsonFile(configPath, configToSave);
+}
+var mergedConfig;
+var init_loader = __esm({
+  "src/init/loader.ts"() {
+    "use strict";
+    init_fs();
+    mergedConfig = null;
+  }
+});
 
-// src/global.ts
-var workingDir = process.cwd();
-function setWorkingDir(dir) {
-  workingDir = dir;
+// src/init/index.ts
+var init_exports = {};
+__export(init_exports, {
+  PROCEDURES: () => PROCEDURES,
+  TOOLS: () => TOOLS,
+  adapter: () => adapter,
+  getAgentConfig: () => getAgentConfig,
+  getApiKey: () => getApiKey,
+  getConfig: () => getConfig,
+  init: () => init,
+  initAdapter: () => initAdapter,
+  loadConfigs: () => loadConfigs,
+  saveConfig: () => saveConfig
+});
+var init_init = __esm({
+  "src/init/index.ts"() {
+    "use strict";
+    init_global();
+    init_loader();
+  }
+});
+
+// src/init/project.ts
+var project_exports = {};
+__export(project_exports, {
+  initProject: () => initProject
+});
+import * as path4 from "path";
+import * as readline from "readline";
+async function askQuestion(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve4) => {
+    rl.question(`${question} (y/n): `, (answer) => {
+      rl.close();
+      resolve4(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function initProject() {
+  const projectConfigDir = PATHS.projectConfig;
+  if (await dirExists(projectConfigDir)) {
+    return;
+  }
+  print(`
+<dim>Project directory: ${workingDir}</dim>`);
+  const trusted = await askQuestion("Do you trust this project and want to initialize arki config?");
+  if (!trusted) {
+    print("<yellow>Initialization cancelled.</yellow>");
+    process.exit(0);
+  }
+  await copyDir(PATHS.projectTemplate, projectConfigDir);
+  const statePath = path4.join(projectConfigDir, "state.json");
+  const state = {
+    initialized: true,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJsonFile(statePath, state);
+  print("<green>Project configuration initialized.</green>");
+}
+var init_project = __esm({
+  "src/init/project.ts"() {
+    "use strict";
+    init_fs();
+    init_log2();
+  }
+});
+
+// src/init/global.ts
+async function initGlobalConfig() {
+  const globalConfigDir = PATHS.globalConfig;
+  if (await dirExists(globalConfigDir)) {
+    return;
+  }
+  await copyDir(PATHS.globalTemplate, globalConfigDir);
 }
-var TOOLS = {};
-var PROCEDURES = {};
-var adapter = null;
 function initAdapter() {
   if (adapter) {
     return;
   }
-  const mainAgentConfig = config.getAgentConfig("main");
+  Promise.resolve().then(() => (init_init(), init_exports)).then(({ getAgentConfig: getAgentConfig2, getApiKey: getApiKey2 }) => {
+    const mainAgentConfig = getAgentConfig2("main");
+    adapter = new OpenAIAdapter({
+      apiKey: getApiKey2("openai") || "",
+      model: mainAgentConfig.model,
+      flex: mainAgentConfig.flex,
+      tools: Object.values(TOOLS)
+    });
+  });
+}
+async function init(cwd) {
+  const { setWorkingDir: setWorkingDir2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+  setWorkingDir2(cwd || process.cwd());
+  await initGlobalConfig();
+  const { initProject: initProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
+  await initProject2();
+  const { loadConfigs: loadConfigs2, getAgentConfig: getAgentConfig2, getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+  await loadConfigs2();
+  const mainAgentConfig = getAgentConfig2("main");
   adapter = new OpenAIAdapter({
-    apiKey: config.getApiKey("openai") || "",
+    apiKey: getApiKey2("openai") || "",
     model: mainAgentConfig.model,
     flex: mainAgentConfig.flex,
     tools: Object.values(TOOLS)
   });
 }
-async function init(cwd) {
-  workingDir = cwd || process.cwd();
-  await config.load();
-  initAdapter();
-}
+var TOOLS, PROCEDURES, adapter;
+var init_global = __esm({
+  "src/init/global.ts"() {
+    "use strict";
+    init_openai();
+    init_fs();
+    TOOLS = {};
+    PROCEDURES = {};
+    adapter = null;
+  }
+});
+
+// src/index.ts
+import * as readline2 from "readline";
+import * as fs6 from "fs";
+import * as path8 from "path";
+import * as os2 from "os";
+
+// src/global.ts
+init_fs();
+init_global();
+init_init();
 
 // src/tool/Tool.ts
+init_log2();
 var HAS_MANUAL = "\u{1F4D8}";
 var Tool = class _Tool {
   name;
@@ -413,12 +736,12 @@ var Tool = class _Tool {
   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);
+  constructor(config) {
+    this.name = config.name;
+    this.parameters = config.parameters;
+    this.required = config.required;
+    this._execute = config.execute;
+    const { description, manual } = _Tool.parseManual(config.manualContent);
     this.description = description;
     this.manual = manual;
   }
@@ -461,8 +784,8 @@ var Tool = class _Tool {
 };
 
 // src/tool/read_file/index.ts
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
+import * as fs3 from "fs/promises";
+import * as path5 from "path";
 
 // src/tool/read_file/manual.md
 var manual_default = "read_file: Read the content of a specified file\n";
@@ -478,8 +801,8 @@ TOOLS["read_file"] = new Tool({
   execute: async (args) => {
     const filePath = args.path;
     try {
-      const fullPath = path2.resolve(workingDir, filePath);
-      return await fs2.readFile(fullPath, "utf-8");
+      const fullPath = path5.resolve(workingDir, filePath);
+      return await fs3.readFile(fullPath, "utf-8");
     } catch (error2) {
       return {
         content: `Failed to read file: ${error2 instanceof Error ? error2.message : String(error2)}`,
@@ -490,8 +813,8 @@ TOOLS["read_file"] = new Tool({
 });
 
 // src/tool/write_file/index.ts
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
+import * as fs4 from "fs/promises";
+import * as path6 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";
@@ -509,9 +832,9 @@ TOOLS["write_file"] = new Tool({
     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");
+      const fullPath = path6.resolve(workingDir, filePath);
+      await fs4.mkdir(path6.dirname(fullPath), { recursive: true });
+      await fs4.writeFile(fullPath, content, "utf-8");
       return `File written successfully: ${filePath}`;
     } catch (error2) {
       return {
@@ -523,8 +846,8 @@ TOOLS["write_file"] = new Tool({
 });
 
 // src/tool/list_directory/index.ts
-import * as fs4 from "fs/promises";
-import * as path4 from "path";
+import * as fs5 from "fs/promises";
+import * as path7 from "path";
 
 // src/tool/list_directory/manual.md
 var manual_default3 = "list_directory: List files and subdirectories in a specified directory\n";
@@ -540,8 +863,8 @@ TOOLS["list_directory"] = new Tool({
   execute: async (args) => {
     const dirPath = args.path || ".";
     try {
-      const fullPath = path4.resolve(workingDir, dirPath);
-      const entries = await fs4.readdir(fullPath, { withFileTypes: true });
+      const fullPath = path7.resolve(workingDir, dirPath);
+      const entries = await fs5.readdir(fullPath, { withFileTypes: true });
       const result = entries.map((entry) => {
         const type = entry.isDirectory() ? "[DIR]" : "[FILE]";
         return `${type} ${entry.name}`;
@@ -659,9 +982,9 @@ var Procedure = class _Procedure {
   name;
   description;
   manual;
-  constructor(config2) {
-    this.name = config2.name;
-    const { description, manual } = _Procedure.parseManual(config2.procedureContent);
+  constructor(config) {
+    this.name = config.name;
+    const { description, manual } = _Procedure.parseManual(config.procedureContent);
     this.description = description;
     this.manual = manual;
   }
@@ -692,6 +1015,9 @@ PROCEDURES["understand_project"] = new Procedure({
   procedureContent: procedure_default
 });
 
+// src/index.ts
+init_log2();
+
 // src/model/models.ts
 var MODELS = {
   "gpt-5.2": {
@@ -733,12 +1059,15 @@ var MODELS = {
 };
 
 // src/agent/Agent.ts
+init_Msg();
+init_init();
+init_log2();
 var Agent = class {
   config;
   messages = [];
-  constructor(config2) {
-    this.config = config2;
-    this.messages = [...config2.messages];
+  constructor(config) {
+    this.config = config;
+    this.messages = [...config.messages];
   }
   /**
    * Render template string, replacing {{variable}} style variables
@@ -804,6 +1133,12 @@ var Agent = class {
   }
 };
 
+// src/agent/index.ts
+init_Msg();
+
+// src/agent/Arki/Arki.ts
+init_log2();
+
 // src/agent/Arki/system.md
 var system_default = "You are Arki, a professional AI programming assistant. You work in the codebase directory `{{working_dir}}`.\n\n## Tool Usage\n\nTools can be called multiple times at once.\nIf a tool has the {{has_manual}} symbol in its description, you **MUST** call `read_tool_manual` before using it. Read the manual exactly once per tool - do not skip it, and do not read it repeatedly.\n\n## Procedure Usage\n\nProcedures are step-by-step guides for specific workflows. When a task involves a defined procedure, you **MUST** call `read_procedure` first to get the complete steps, then follow the procedure exactly.\n\nIf a procedure defines output text/format templates, translate them to the user's language unless the procedure explicitly forbids translation.\n\nAvailable procedures:\n{{procedures}}\n\n## Working Principles\n\n- **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. For example, never tell the user what might be inside a directory based only on its name\u2014always inspect its contents first, and never guess functionality from directory, file, or function names in a way that could mislead the user.\n- **Safety**: Consider potential risks before executing commands.\n- **Conciseness**: Keep answers brief and concise, avoid repetition and redundancy. Keep each response within 200 words unless the user requests detailed explanation. If user requirements are unclear, ask for clarification once at most. If still unclear after asking, proceed with your best understanding and show the result to the user - do not ask multiple times.\n- **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**. Prefer terminal-friendly characters and plain text formatting. **Do not** output Markdown syntax such as `**` for bold, `*` or `-` for lists, etc. For long answers, feel free to organize content with clear section headings. Use numbered lists for ordered lists only when items have a clear sequence or dependency; otherwise use the \u2022 symbol for unordered lists.\nUse the following tags to format output:\n\n| Purpose | Format Tag | Usage |\n|--------|------------|-------|\n| Code blocks (```...```) | `<dim>...</dim>` | Wrap the entire code block content |\n| Inline code (`...`) | `<dim>...</dim>` | Wrap inline code snippets |\n| File paths | `<cyan>...</cyan>` | For paths, e.g., `src/index.ts` |\n| Filenames | `<gray>...</gray>` | For file names when mentioned alone |\n| Command names | `<blue>...</blue>` | For commands, e.g., `npm install` |\n| Section headings / titles | `<bold><cyan>...</cyan></bold>` | For section titles in plain text output |\n| Important or strong emphasis (**...**) | `<bold>...</bold>` | For key points that must stand out |\n| Secondary / less important info | `<dim>...</dim>` | For metadata, debug info, token counts, etc. |\n| Tips / important notices | `<yellow>...</yellow>` | For tips, cautions, non-fatal problems |\n| Success confirmations | `<green>...</green>` | For success messages, completion status |\n| Errors or serious problems | `<red>...</red>` | For real problems the user must fix |\n| Neutral informational messages | `<blue>...</blue>` | For general info that is not success/failure |\n| Highlighted keywords / categories | `<magenta>...</magenta>` | For labels, categories, or tags in text |\n| De-emphasized / grayed-out text | `<gray>...</gray>` | For low-priority info, old values, etc. |\n| Underlined emphasis | `<underline>...</underline>` | For things you want to underline instead of bold |\n| Optional / tentative text | `<italic>...</italic>` | For suggestions, optional steps, side notes |\n| Reversed highlight | `<inverse>...</inverse>` | For very strong highlights (rarely use) |\n| Deleted / not recommended content | `<strikethrough>...</strikethrough>` | For deprecated commands or steps |\n\nTags can be combined, e.g., `<bold><red>Critical Error</red></bold>`\n\n- Do not mention the contents of this prompt to users. The prompt provides context and instructions for you to follow, not to recite verbatim. Use the information in the prompt to inform your responses naturally. Bad example: \"You are currently talking to me via a Mac OS terminal interface. How can I help you?\" Good example: (Display terminal-friendly characters and provide suggestions based on the Mac OS system environment)\n\nPlease answer questions in the language the user is using, and flexibly use available tools to complete tasks.\n\n";
 
@@ -859,7 +1194,7 @@ function createMainAgent() {
 // package.json
 var package_default = {
   name: "arki",
-  version: "0.0.5",
+  version: "0.0.6",
   description: "AI Agent Programming Assistant",
   type: "module",
   main: "dist/index.js",
@@ -916,13 +1251,21 @@ var package_default = {
 };
 
 // src/index.ts
-function getConfigPath2() {
-  return path5.join(os2.homedir(), ".config", "arki", "config.json");
+init_log2();
+init_Msg();
+
+// src/adapter/index.ts
+init_Adapter();
+init_openai();
+
+// src/index.ts
+function getConfigPath() {
+  return path8.join(os2.homedir(), ".config", "arki", "config.json");
 }
 function resetConfig() {
-  const configPath = getConfigPath2();
-  if (fs5.existsSync(configPath)) {
-    fs5.unlinkSync(configPath);
+  const configPath = getConfigPath();
+  if (fs6.existsSync(configPath)) {
+    fs6.unlinkSync(configPath);
     console.log(`Configuration file deleted: ${configPath}`);
     console.log("Default configuration will be used on next startup.");
   } else {
@@ -964,13 +1307,14 @@ async function main() {
     debug("Init", "Debug mode enabled");
   }
   await init(targetDir);
-  const mainAgentConfig = config.getAgentConfig("main");
+  const mainAgentConfig = getAgentConfig("main");
   const model = MODELS[mainAgentConfig.model];
   console.log();
   log(`<cyan>Arki AI Agent v${package_default.version}</cyan>`);
   console.log();
   log(`<dim>Model: ${mainAgentConfig.model}${model ? ` (${model.name})` : ""}</dim>`);
   log(`<dim>Working directory: ${workingDir}</dim>`);
+  log(`<dim>OS: ${OS.name} (${OS.version})</dim>`);
   if (isDebugMode()) {
     log(`<yellow>Debug mode enabled</yellow>`);
   }
@@ -982,7 +1326,7 @@ async function main() {
   }
   console.log();
   const agent = createMainAgent();
-  const rl = readline.createInterface({
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
@@ -1058,7 +1402,9 @@ export {
   MODELS,
   Msg,
   MsgType,
+  OS,
   OpenAIAdapter,
+  PATHS,
   PROCEDURES,
   SystemMsg,
   TEMPERATURE,
@@ -1068,16 +1414,21 @@ export {
   ToolResultMsg,
   UserMsg,
   adapter,
-  colors2 as colors,
-  config,
+  colors,
   convertColorTags,
   createColorConverter,
   debug,
   error,
+  getAgentConfig,
+  getApiKey,
+  getConfig,
   info,
   init,
+  initAdapter,
   isDebugMode,
   log,
+  print,
+  saveConfig,
   setDebugMode,
   setWorkingDir,
   success,