arki 0.0.6 → 0.0.7

package/README.md

@@ -45,6 +45,7 @@ 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
 ```
@@ -99,6 +100,7 @@ Each project can have its own configuration in `.arki/` directory:
 - `.arki/state.json` - Project state and cache
 
 On first run in a new project, Arki will ask if you trust the project before initializing the `.arki/` directory.
+Use `--init` to skip the prompt in non-interactive environments.
 
 ### Reset to Factory Defaults
 

package/dist/config/arki/config.json

@@ -1,6 +1,6 @@
 {
   "agents": {
-    "main": {
+    "arki": {
       "model": "gpt-5.1",
       "flex": true,
       "reasoningEffort": "medium"

package/dist/index.d.ts

@@ -160,15 +160,16 @@ declare const PATHS: {
     projectTemplate: string;
 };
 
-/**
- * Fixed parameters
- */
-declare const TEMPERATURE = 0.2;
-declare const MAX_COMPLETION_TOKENS = 4096;
 /**
  * Reasoning effort
  */
 type ReasoningEffort$1 = 'low' | 'medium' | 'high';
+/**
+ * Platform-specific options for adapter
+ */
+interface AdapterOptions {
+    [key: string]: unknown;
+}
 /**
  * LLM response result
  */
@@ -184,45 +185,31 @@ interface AdapterResponse {
 }
 /**
  * LLM adapter base class
+ * Only contains platform authentication, model/tools belong to Agent
  */
 declare abstract class Adapter {
     protected apiKey: string;
-    protected model: string;
-    /** Use Flex API (OpenAI) - low priority, low cost */
-    protected flex?: boolean;
-    /** Reasoning effort (thinking mode) */
-    protected reasoningEffort?: ReasoningEffort$1;
-    /** Available tools list */
-    protected tools?: Tool[];
-    constructor(config: {
-        apiKey: string;
-        model: string;
-        /** Use Flex API (OpenAI) - low priority, low cost */
-        flex?: boolean;
-        /** Reasoning effort (thinking mode) */
-        reasoningEffort?: ReasoningEffort$1;
-        /** Available tools list */
-        tools?: Tool[];
-    });
-    abstract chat(messages: Msg[], onChunk?: (chunk: string) => void): Promise<AdapterResponse>;
-    getModel(): string;
+    constructor(apiKey: string);
+    abstract chat(model: string, messages: Msg[], tools: Tool[], options: AdapterOptions, onChunk?: (chunk: string) => void): Promise<AdapterResponse>;
 }
 
 /** Global tool registry */
 declare const TOOLS: Record<string, Tool>;
 /** Global procedure registry */
 declare const PROCEDURES: Record<string, Procedure>;
-/** Global Adapter instance */
-declare let adapter: Adapter | null;
-/** Initialize global Adapter */
-declare function initAdapter(): void;
+/** Global adapter registry by platform */
+declare const adapters: Record<string, Adapter>;
+/**
+ * Get adapter by platform name
+ */
+declare function getAdapter(platform: string): Adapter;
 /** Initialize global state */
-declare function init(cwd?: string): Promise<void>;
+declare function init(cwd?: string, forceInit?: boolean): Promise<void>;
 
 /**
  * Agent type
  */
-type AgentType = 'main' | 'coder';
+type AgentType = 'arki' | 'coder';
 /**
  * Reasoning effort
  */
@@ -231,23 +218,17 @@ type ReasoningEffort = 'low' | 'medium' | 'high';
  * Agent model configuration
  */
 interface AgentModelConfig {
-    /** Model ID */
+    /** Model ID (provider is derived from MODELS) */
     model: string;
-    /** Use Flex API (low priority, low cost) */
+    /** Use Flex API (low priority, low cost) - OpenAI specific */
     flex?: boolean;
     /** Reasoning effort (thinking mode) */
     reasoningEffort?: ReasoningEffort;
 }
 /**
- * Global configuration
+ * Global configuration (from config files)
  */
 interface GlobalConfig {
-    apiKeys?: {
-        openai?: string;
-        anthropic?: string;
-        google?: string;
-        [key: string]: string | undefined;
-    };
     agents: {
         [K in AgentType]?: AgentModelConfig;
     };
@@ -257,7 +238,7 @@ interface GlobalConfig {
  */
 declare function getConfig(): GlobalConfig;
 /**
- * Get API key for a provider
+ * Get API key from environment variable
  */
 declare function getApiKey(provider: string): string | undefined;
 /**
@@ -355,18 +336,23 @@ declare function convertColorTags(str: string): string;
  */
 declare function createColorConverter(): (chunk: string) => string;
 
+/**
+ * OpenAI-specific options
+ */
+interface OpenAIOptions extends AdapterOptions {
+    /** Use Flex API - low priority, low cost */
+    flex?: boolean;
+    /** Reasoning effort (thinking mode) */
+    reasoningEffort?: ReasoningEffort$1;
+    /** Maximum completion tokens for LLM response */
+    maxCompletionTokens?: number;
+}
 declare class OpenAIAdapter extends Adapter {
     private client;
-    constructor(config: {
-        apiKey: string;
-        model: string;
-        flex?: boolean;
-        reasoningEffort?: 'low' | 'medium' | 'high';
-        tools?: Tool[];
-    });
+    constructor(apiKey: string);
     private toOpenAIMessages;
-    private getTools;
-    chat(messages: Msg[], onChunk?: (chunk: string) => void): Promise<AdapterResponse>;
+    private formatTools;
+    chat(model: string, messages: Msg[], tools: Tool[], options: OpenAIOptions, onChunk?: (chunk: string) => void): Promise<AdapterResponse>;
 }
 
 interface AgentResponse {
@@ -383,17 +369,24 @@ interface AgentResponse {
         cachedTokens?: number;
     };
 }
+interface AgentConfig {
+    adapter: Adapter;
+    model: string;
+    tools: Tool[];
+    platformOptions?: AdapterOptions;
+    messages: Msg[];
+    /** Maximum completion tokens for LLM response */
+    maxCompletionTokens?: number;
+    onStream?: (chunk: string) => void;
+    onToolCallMsg?: (msg: ToolCallMsg) => void;
+    onBeforeToolRun?: (name: string, args: Record<string, unknown>) => void;
+    onToolResult?: (name: string, args: Record<string, unknown>, result: string) => void;
+}
 declare class Agent {
     private config;
     private messages;
-    constructor(config: {
-        adapter: Adapter;
-        messages: Msg[];
-        onStream?: (chunk: string) => void;
-        onToolCallMsg?: (msg: ToolCallMsg) => void;
-        onBeforeToolRun?: (name: string, args: Record<string, unknown>) => void;
-        onToolResult?: (name: string, args: Record<string, unknown>, result: string) => void;
-    });
+    private toolsMap;
+    constructor(config: AgentConfig);
     /**
      * Render template string, replacing {{variable}} style variables
      */
@@ -428,4 +421,4 @@ interface Model {
     readonly capabilities: ModelCapabilities;
 }
 
-export { AIMsg, Adapter, type AdapterResponse, Agent, type AgentModelConfig, type AgentResponse, type AgentType, type ColorName, type GlobalConfig, HAS_MANUAL, MAX_COMPLETION_TOKENS, MODELS, type Model, type ModelCapabilities, type ModelProvider, Msg, MsgType, OS, type OS_TYPE, OpenAIAdapter, PATHS, PROCEDURES, type ReasoningEffort$1 as ReasoningEffort, SystemMsg, TEMPERATURE, TOOLS, Tool, type ToolCall, ToolCallMsg, type ToolResult, ToolResultMsg, UserMsg, adapter, colors, convertColorTags, createColorConverter, debug, error, getAgentConfig, getApiKey, getConfig, info, init, initAdapter, isDebugMode, log, print, saveConfig, setDebugMode, setWorkingDir, success, warn, workingDir };
+export { AIMsg, Adapter, type AdapterOptions, type AdapterResponse, Agent, type AgentModelConfig, type AgentResponse, type AgentType, type ColorName, type GlobalConfig, HAS_MANUAL, MODELS, type Model, type ModelCapabilities, type ModelProvider, Msg, MsgType, OS, type OS_TYPE, OpenAIAdapter, type OpenAIOptions, PATHS, PROCEDURES, type ReasoningEffort$1 as ReasoningEffort, SystemMsg, TOOLS, Tool, type ToolCall, ToolCallMsg, type ToolResult, ToolResultMsg, UserMsg, adapters, colors, convertColorTags, createColorConverter, debug, error, getAdapter, getAgentConfig, getApiKey, getConfig, info, init, isDebugMode, log, print, saveConfig, setDebugMode, setWorkingDir, success, warn, workingDir };

package/dist/index.js

@@ -161,98 +161,6 @@ var init_fs = __esm({
   }
 });
 
-// src/adapter/Adapter.ts
-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, 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);
@@ -362,129 +270,6 @@ var init_log2 = __esm({
   }
 });
 
-// src/adapter/openai.ts
-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 });
-      }
-      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;
-      }
-      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);
-        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/init/loader.ts
 var loader_exports = {};
 __export(loader_exports, {
@@ -500,9 +285,6 @@ function deepMerge(base, override) {
     ...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];
@@ -513,26 +295,6 @@ function deepMerge(base, override) {
   }
   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;
@@ -549,7 +311,6 @@ async function loadConfigs() {
   } else {
     mergedConfig = globalConfig;
   }
-  loadEnvApiKeys(mergedConfig);
   return mergedConfig;
 }
 function getConfig() {
@@ -559,7 +320,13 @@ function getConfig() {
   return mergedConfig;
 }
 function getApiKey(provider) {
-  return getConfig().apiKeys?.[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];
@@ -571,20 +338,7 @@ function getAgentConfig(agentType) {
 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);
+  await writeJsonFile(configPath, config);
 }
 var mergedConfig;
 var init_loader = __esm({
@@ -595,28 +349,6 @@ var init_loader = __esm({
   }
 });
 
-// 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, {
@@ -636,14 +368,16 @@ async function askQuestion(question) {
     });
   });
 }
-async function initProject() {
+async function initProject(forceInit) {
   const projectConfigDir = PATHS.projectConfig;
   if (await dirExists(projectConfigDir)) {
     return;
   }
-  print(`
+  const trusted = forceInit ? true : await (async () => {
+    print(`
 <dim>Project directory: ${workingDir}</dim>`);
-  const trusted = await askQuestion("Do you trust this project and want to initialize arki config?");
+    return askQuestion("Do you trust this project and want to initialize arki config?");
+  })();
   if (!trusted) {
     print("<yellow>Initialization cancelled.</yellow>");
     process.exit(0);
@@ -665,66 +399,233 @@ var init_project = __esm({
   }
 });
 
+// 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 Adapter = class {
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+};
+
+// 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 }]);
+  }
+};
+
+// src/adapter/openai.ts
+init_log2();
+var OpenAIAdapter = class extends Adapter {
+  client;
+  constructor(apiKey) {
+    super(apiKey);
+    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
+          });
+        }
+      }
+    }
+    return result;
+  }
+  formatTools(tools) {
+    if (tools.length === 0) return void 0;
+    return 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(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,
+      messages: openaiMessages,
+      tools: this.formatTools(tools),
+      max_completion_tokens: options.maxCompletionTokens,
+      stream: true,
+      stream_options: { include_usage: true },
+      service_tier: options.flex ? "flex" : void 0,
+      reasoning_effort: options.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/init/global.ts
+init_fs();
+var TOOLS = {};
+var PROCEDURES = {};
+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;
-  }
+  if (await dirExists(globalConfigDir)) return;
   await copyDir(PATHS.globalTemplate, globalConfigDir);
 }
-function initAdapter() {
-  if (adapter) {
-    return;
+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);
   }
-  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) {
+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();
-  const { loadConfigs: loadConfigs2, getAgentConfig: getAgentConfig2, getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+  await initProject2(forceInit);
+  const { loadConfigs: loadConfigs2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
   await loadConfigs2();
-  const mainAgentConfig = getAgentConfig2("main");
-  adapter = new OpenAIAdapter({
-    apiKey: getApiKey2("openai") || "",
-    model: mainAgentConfig.model,
-    flex: mainAgentConfig.flex,
-    tools: Object.values(TOOLS)
-  });
+  await initAdapters();
 }
-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/init/index.ts
+init_loader();
 
 // src/tool/Tool.ts
 init_log2();
@@ -1059,15 +960,17 @@ var MODELS = {
 };
 
 // src/agent/Agent.ts
-init_Msg();
-init_init();
 init_log2();
 var Agent = class {
   config;
   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
@@ -1089,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;
@@ -1114,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,
@@ -1133,9 +1045,6 @@ var Agent = class {
   }
 };
 
-// src/agent/index.ts
-init_Msg();
-
 // src/agent/Arki/Arki.ts
 init_log2();
 
@@ -1143,11 +1052,15 @@ init_log2();
 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,
@@ -1157,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));
@@ -1194,7 +1114,7 @@ function createMainAgent() {
 // package.json
 var package_default = {
   name: "arki",
-  version: "0.0.6",
+  version: "0.0.7",
   description: "AI Agent Programming Assistant",
   type: "module",
   main: "dist/index.js",
@@ -1252,13 +1172,6 @@ var package_default = {
 
 // src/index.ts
 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");
 }
@@ -1277,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];
@@ -1285,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]
@@ -1292,40 +1208,36 @@ 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 = getAgentConfig("main");
-  const model = MODELS[mainAgentConfig.model];
+  await init(targetDir, forceInit);
+  const arkiAgentConfig = getAgentConfig("arki");
+  const model = MODELS[arkiAgentConfig.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>`);
+  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 agent = createArkiAgent();
   const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
@@ -1398,7 +1310,6 @@ export {
   Adapter,
   Agent,
   HAS_MANUAL,
-  MAX_COMPLETION_TOKENS,
   MODELS,
   Msg,
   MsgType,
@@ -1407,24 +1318,23 @@ export {
   PATHS,
   PROCEDURES,
   SystemMsg,
-  TEMPERATURE,
   TOOLS,
   Tool,
   ToolCallMsg,
   ToolResultMsg,
   UserMsg,
-  adapter,
+  adapters,
   colors,
   convertColorTags,
   createColorConverter,
   debug,
   error,
+  getAdapter,
   getAgentConfig,
   getApiKey,
   getConfig,
   info,
   init,
-  initAdapter,
   isDebugMode,
   log,
   print,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arki",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "AI Agent Programming Assistant",
   "type": "module",
   "main": "dist/index.js",