arki 0.0.5 → 0.0.7

package/dist/index.js

@@ -1,125 +1,421 @@
 #!/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}`);
+}
+async function writeFile2(filePath, content) {
+  await fs.writeFile(filePath, content, "utf-8");
+}
+var init_file = __esm({
+  "src/fs/file.ts"() {
+    "use strict";
+  }
+});
+
+// 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);
     }
-    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;
-      }
+}
+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/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/log/log.ts
+function getTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+}
+function print(message) {
+  console.log(convertColorTags(message));
+}
+function log(message) {
+  print(`<gray>[${getTimestamp()}]</gray> ${message}`);
+}
+function info(message) {
+  log(`<blue>[INFO]</blue> ${message}`);
+}
+function success(message) {
+  log(`<green>[OK]</green> ${message}`);
+}
+function warn(message) {
+  log(`<yellow>[WARN]</yellow> ${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
+function isDebugMode() {
+  return _debugMode;
+}
+function setDebugMode(enabled) {
+  _debugMode = enabled;
+}
+function formatData(data, maxLen = 100) {
+  if (data === void 0) return "";
+  const str = typeof data === "string" ? data : JSON.stringify(data);
+  const singleLine = str.replace(/\s+/g, " ").trim();
+  return singleLine.length > maxLen ? singleLine.slice(0, maxLen) + "..." : singleLine;
+}
+function debug(category, message, data) {
+  if (!_debugMode) return;
+  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
+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 (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 (buffer.indexOf(">", lastOpen) !== -1) {
+      const out2 = convertColorTags(buffer);
+      buffer = "";
+      return out2;
     }
-    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;
+    const out = convertColorTags(buffer.slice(0, lastOpen));
+    buffer = buffer.slice(lastOpen);
+    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/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.agents) {
+    for (const key of Object.keys(override.agents)) {
+      const overrideAgent = override.agents[key];
+      if (overrideAgent) {
+        result.agents[key] = { ...result.agents[key], ...overrideAgent };
       }
     }
   }
-};
-var config = new ConfigManager();
+  return result;
+}
+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;
+  }
+  return mergedConfig;
+}
+function getConfig() {
+  if (!mergedConfig) {
+    throw new Error("Config not loaded yet. Please call loadConfigs() first.");
+  }
+  return mergedConfig;
+}
+function getApiKey(provider) {
+  const envMap = {
+    openai: "OPENAI_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+    google: "GOOGLE_API_KEY"
+  };
+  const envVar = envMap[provider] || `${provider.toUpperCase()}_API_KEY`;
+  return process.env[envVar];
+}
+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");
+  await writeJsonFile(configPath, config);
+}
+var mergedConfig;
+var init_loader = __esm({
+  "src/init/loader.ts"() {
+    "use strict";
+    init_fs();
+    mergedConfig = null;
+  }
+});
+
+// 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(forceInit) {
+  const projectConfigDir = PATHS.projectConfig;
+  if (await dirExists(projectConfigDir)) {
+    return;
+  }
+  const trusted = forceInit ? true : await (async () => {
+    print(`
+<dim>Project directory: ${workingDir}</dim>`);
+    return 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/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();
 
 // 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;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
   }
 };
 
@@ -179,97 +475,12 @@ var ToolResultMsg = class _ToolResultMsg extends Msg {
   }
 };
 
-// src/log/log.ts
-function getTimestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
-}
-function log(message) {
-  const ts = `<gray>[${getTimestamp()}]</gray>`;
-  console.log(convertColorTags(`${ts} ${message}`));
-}
-function info(message) {
-  log(`<blue>[INFO]</blue> ${message}`);
-}
-function success(message) {
-  log(`<green>[OK]</green> ${message}`);
-}
-function warn(message) {
-  log(`<yellow>[WARN]</yellow> ${message}`);
-}
-function error(message) {
-  log(`<red>[ERROR]</red> ${message}`);
-}
-
-// src/log/debug.ts
-var _debugMode = false;
-function isDebugMode() {
-  return _debugMode;
-}
-function setDebugMode(enabled) {
-  _debugMode = enabled;
-}
-function formatData(data, maxLen = 100) {
-  if (data === void 0) return "";
-  const str = typeof data === "string" ? data : JSON.stringify(data);
-  const singleLine = str.replace(/\s+/g, " ").trim();
-  return singleLine.length > maxLen ? singleLine.slice(0, maxLen) + "..." : singleLine;
-}
-function debug(category, message, data) {
-  if (!_debugMode) return;
-  const dataStr = data !== void 0 ? ` <dim>${formatData(data)}</dim>` : "";
-  log(`<magenta>[${category}]</magenta> <cyan>${message}</cyan>${dataStr}`);
-}
-
-// 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()] || "";
-  });
-}
-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/adapter/openai.ts
+init_log2();
 var OpenAIAdapter = class extends Adapter {
   client;
-  constructor(config2) {
-    super(config2);
+  constructor(apiKey) {
+    super(apiKey);
     if (!this.apiKey) {
       throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable.");
     }
@@ -308,8 +519,9 @@ var OpenAIAdapter = class extends Adapter {
     }
     return result;
   }
-  getTools() {
-    return this.tools?.map((t) => ({
+  formatTools(tools) {
+    if (tools.length === 0) return void 0;
+    return tools.map((t) => ({
       type: "function",
       function: {
         name: t.name,
@@ -322,20 +534,19 @@ var OpenAIAdapter = class extends Adapter {
       }
     }));
   }
-  async chat(messages, onChunk) {
-    debug("API", `Requesting OpenAI (model: ${this.model}, messages: ${messages.length})`);
+  async chat(model, messages, tools, options, onChunk) {
+    debug("API", `Requesting OpenAI (model: ${model}, messages: ${messages.length})`);
     const openaiMessages = this.toOpenAIMessages(messages);
     const startTime = Date.now();
     const requestParams = {
-      model: this.model,
+      model,
       messages: openaiMessages,
-      tools: this.getTools(),
-      temperature: TEMPERATURE,
-      max_completion_tokens: MAX_COMPLETION_TOKENS,
+      tools: this.formatTools(tools),
+      max_completion_tokens: options.maxCompletionTokens,
       stream: true,
       stream_options: { include_usage: true },
-      service_tier: this.flex ? "flex" : void 0,
-      reasoning_effort: this.reasoningEffort
+      service_tier: options.flex ? "flex" : void 0,
+      reasoning_effort: options.reasoningEffort
     };
     const stream = await this.client.chat.completions.create(requestParams);
     let text = "";
@@ -378,33 +589,46 @@ var OpenAIAdapter = class extends Adapter {
   }
 };
 
-// src/global.ts
-var workingDir = process.cwd();
-function setWorkingDir(dir) {
-  workingDir = dir;
-}
+// src/init/global.ts
+init_fs();
 var TOOLS = {};
 var PROCEDURES = {};
-var adapter = null;
-function initAdapter() {
-  if (adapter) {
-    return;
+var adapters = {};
+function getAdapter(platform) {
+  const adapter = adapters[platform];
+  if (!adapter) {
+    throw new Error(`Adapter not found for platform: ${platform}`);
+  }
+  return adapter;
+}
+async function initGlobalConfig() {
+  const globalConfigDir = PATHS.globalConfig;
+  if (await dirExists(globalConfigDir)) return;
+  await copyDir(PATHS.globalTemplate, globalConfigDir);
+}
+async function initAdapters() {
+  const { getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+  const openaiKey = getApiKey2("openai");
+  if (openaiKey) {
+    adapters["openai"] = new OpenAIAdapter(openaiKey);
   }
-  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();
+async function init(cwd, forceInit) {
+  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(forceInit);
+  const { loadConfigs: loadConfigs2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+  await loadConfigs2();
+  await initAdapters();
 }
 
+// src/init/index.ts
+init_loader();
+
 // src/tool/Tool.ts
+init_log2();
 var HAS_MANUAL = "\u{1F4D8}";
 var Tool = class _Tool {
   name;
@@ -413,12 +637,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 +685,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 +702,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 +714,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 +733,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 +747,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 +764,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 +883,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 +916,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 +960,17 @@ var MODELS = {
 };
 
 // src/agent/Agent.ts
+init_log2();
 var Agent = class {
   config;
   messages = [];
-  constructor(config2) {
-    this.config = config2;
-    this.messages = [...config2.messages];
+  toolsMap = {};
+  constructor(config) {
+    this.config = config;
+    this.messages = [...config.messages];
+    for (const tool of config.tools) {
+      this.toolsMap[tool.name] = tool;
+    }
   }
   /**
    * Render template string, replacing {{variable}} style variables
@@ -760,7 +992,16 @@ var Agent = class {
     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);
+      const response = await this.config.adapter.chat(
+        this.config.model,
+        this.messages,
+        this.config.tools,
+        {
+          ...this.config.platformOptions,
+          maxCompletionTokens: this.config.maxCompletionTokens
+        },
+        this.config.onStream
+      );
       if (response.usage) {
         totalUsage.promptTokens += response.usage.promptTokens;
         totalUsage.completionTokens += response.usage.completionTokens;
@@ -785,7 +1026,7 @@ var Agent = class {
       const toolResults = [];
       for (const tc of toolCalls) {
         this.config.onBeforeToolRun?.(tc.name, tc.arguments);
-        const tool = TOOLS[tc.name];
+        const tool = this.toolsMap[tc.name];
         const result = tool ? await tool.run(tc.arguments) : { toolName: tc.name, result: `Unknown tool: ${tc.name}`, isError: true };
         toolCallHistory.push({
           name: tc.name,
@@ -804,15 +1045,22 @@ var Agent = class {
   }
 };
 
+// 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";
 
 // src/agent/Arki/Arki.ts
+var MAX_COMPLETION_TOKENS = 4096;
 var toolStartTimes = /* @__PURE__ */ new Map();
-function createMainAgent() {
-  if (!adapter) {
-    throw new Error("Adapter not initialized, please call init() first");
+function createArkiAgent() {
+  const config = getAgentConfig("arki");
+  const model = MODELS[config.model];
+  if (!model) {
+    throw new Error(`Unknown model: ${config.model}`);
   }
+  const adapter = getAdapter(model.provider);
   const proceduresList = Object.values(PROCEDURES).map((p) => `- ${p.name}: ${p.description}`).join("\n");
   const systemInstruction = Agent.renderTemplate(system_default, {
     working_dir: workingDir,
@@ -822,6 +1070,13 @@ function createMainAgent() {
   const convertColor = createColorConverter();
   const agent = new Agent({
     adapter,
+    model: config.model,
+    tools: Object.values(TOOLS),
+    maxCompletionTokens: MAX_COMPLETION_TOKENS,
+    platformOptions: {
+      flex: config.flex,
+      reasoningEffort: config.reasoningEffort
+    },
     messages: [new SystemMsg(systemInstruction)],
     onStream: (chunk) => {
       process.stdout.write(convertColor(chunk));
@@ -859,7 +1114,7 @@ function createMainAgent() {
 // package.json
 var package_default = {
   name: "arki",
-  version: "0.0.5",
+  version: "0.0.7",
   description: "AI Agent Programming Assistant",
   type: "module",
   main: "dist/index.js",
@@ -916,13 +1171,14 @@ var package_default = {
 };
 
 // src/index.ts
-function getConfigPath2() {
-  return path5.join(os2.homedir(), ".config", "arki", "config.json");
+init_log2();
+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 {
@@ -934,6 +1190,7 @@ function parseArgs() {
   const args = process.argv.slice(2);
   let targetDir = process.cwd();
   let enableDebug = false;
+  let forceInit = false;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "-p" && args[i + 1]) {
       targetDir = args[i + 1];
@@ -942,6 +1199,8 @@ function parseArgs() {
       enableDebug = true;
     } else if (args[i] === "--reset") {
       resetConfig();
+    } else if (args[i] === "--init") {
+      forceInit = true;
     } else if (args[i] === "--help" || args[i] === "-h") {
       console.log(`
 Usage: arki [options]
@@ -949,40 +1208,37 @@ Usage: arki [options]
 Options:
   -p <path>      Specify working directory
   --debug, -d    Enable debug mode, show detailed logs
+  --init         Initialize project config without prompting
   --reset        Reset configuration to factory defaults
   --help, -h     Show help information
 `);
       process.exit(0);
     }
   }
-  return { targetDir, enableDebug };
+  return { targetDir, enableDebug, forceInit };
 }
 async function main() {
-  const { targetDir, enableDebug } = parseArgs();
+  const { targetDir, enableDebug, forceInit } = 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}</cyan>`);
+  await init(targetDir, forceInit);
+  const arkiAgentConfig = getAgentConfig("arki");
+  const model = MODELS[arkiAgentConfig.model];
   console.log();
-  log(`<dim>Model: ${mainAgentConfig.model}${model ? ` (${model.name})` : ""}</dim>`);
-  log(`<dim>Working directory: ${workingDir}</dim>`);
+  log(`<bold><cyan>Arki AI Agent</cyan></bold> <dim>v${package_default.version}</dim>`);
+  log(`<green>Model:</green> <bold>${model?.name || arkiAgentConfig.model}</bold> <dim>|</dim> <green>OS:</green> ${OS.name} <dim>(${OS.version})</dim>`);
+  log(`<green>Path:</green> <dim>${workingDir}</dim>`);
+  log(`<green>Tools:</green> ${Object.keys(TOOLS).length} loaded`);
   if (isDebugMode()) {
     log(`<yellow>Debug mode enabled</yellow>`);
-  }
-  console.log();
-  log(`<dim>Loaded ${Object.keys(TOOLS).length} tools</dim>`);
-  if (isDebugMode()) {
     debug("Init", "Loaded tools", Object.keys(TOOLS));
-    debug("Init", "Agent config", mainAgentConfig);
+    debug("Init", "Agent config", arkiAgentConfig);
   }
   console.log();
-  const agent = createMainAgent();
-  const rl = readline.createInterface({
+  const agent = createArkiAgent();
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
@@ -1054,30 +1310,35 @@ export {
   Adapter,
   Agent,
   HAS_MANUAL,
-  MAX_COMPLETION_TOKENS,
   MODELS,
   Msg,
   MsgType,
+  OS,
   OpenAIAdapter,
+  PATHS,
   PROCEDURES,
   SystemMsg,
-  TEMPERATURE,
   TOOLS,
   Tool,
   ToolCallMsg,
   ToolResultMsg,
   UserMsg,
-  adapter,
-  colors2 as colors,
-  config,
+  adapters,
+  colors,
   convertColorTags,
   createColorConverter,
   debug,
   error,
+  getAdapter,
+  getAgentConfig,
+  getApiKey,
+  getConfig,
   info,
   init,
   isDebugMode,
   log,
+  print,
+  saveConfig,
   setDebugMode,
   setWorkingDir,
   success,