arki 0.0.3 → 0.0.5

package/README.md

@@ -1,3 +1,5 @@
+> **⚠️ Warning: This project is under active development. Please do not use it in production environments.**
+
 # Arki - AI Agent Programming Assistant
 
 Arki is an AI agent programming tool.
@@ -43,6 +45,7 @@ arki [options]
 Options:
   -p <path>      Specify working directory
   --debug, -d    Enable debug mode, show detailed logs
+  --reset        Reset configuration to factory defaults
   --help, -h     Show help information
 ```
 
@@ -81,39 +84,13 @@ Ways to enable:
 
 Configuration file is located at `~/.config/arki/config.json`:
 
-```json
-{
-  "agents": {
-    "main": {
-      "model": "gpt-5.1",
-      "flex": false,
-      "reasoningEffort": "medium"
-    },
-    "coder": {
-      "model": "gpt-5.2",
-      "flex": false,
-      "reasoningEffort": "high"
-    }
-  }
-}
-```
-
-Each Agent configuration:
-- `model` - Model ID to use
-- `flex` - Use Flex API (low priority, low cost)
-- `reasoningEffort` - Reasoning effort, optional values: `low`, `medium`, `high` (for models that support thinking mode)
-
-Default configuration is automatically copied from the package on first run.
+### Reset to Factory Defaults
 
-## Built-in Tools
-
-Arki includes the following built-in tools that the AI assistant can automatically call:
+```bash
+arki --reset
+```
 
-- `read_file` - Read file content
-- `write_file` - Write to file
-- `list_directory` - List directory contents
-- `run_command` - Execute shell commands
-- `get_tool_info` - View detailed usage instructions for tools
+This will delete the current configuration file. The default configuration will be used on next startup.
 
 ## Development
 

package/dist/index.d.ts

@@ -39,31 +39,44 @@ declare class AIMsg extends Msg {
     readonly type = MsgType.AI;
     constructor(content: string);
 }
+/**
+ * Single tool call
+ */
+interface ToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+}
 /**
  * Tool call message constructor
  */
 declare class ToolCallMsg extends Msg {
     readonly type = MsgType.ToolCall;
-    readonly toolCalls: Array<{
-        name: string;
-        arguments: Record<string, unknown>;
-    }>;
-    constructor(content: string, toolCalls: Array<{
-        name: string;
-        arguments: Record<string, unknown>;
-    }>);
+    readonly toolCalls: ToolCall[];
+    constructor(content: string, toolCalls: ToolCall[]);
 }
 /**
- * Tool result message constructor
+ * Single tool result
+ */
+interface ToolResult {
+    toolName: string;
+    result: string;
+    isError?: boolean;
+}
+/**
+ * Tool result message constructor (contains multiple results)
  */
 declare class ToolResultMsg extends Msg {
     readonly type = MsgType.ToolResult;
-    readonly toolName: string;
-    readonly result: string;
-    readonly isError?: boolean;
-    constructor(toolName: string, result: string, isError?: boolean);
+    readonly toolResults: ToolResult[];
+    constructor(toolResults: ToolResult[]);
+    /** Helper: create from single result */
+    static single(toolName: string, result: string, isError?: boolean): ToolResultMsg;
 }
 
+/**
+ * Symbol indicating tool has detailed manual (needs to call read_tool_manual before use)
+ */
+declare const HAS_MANUAL = "\uD83D\uDCD8";
 /**
  * Tool class
  */
@@ -88,6 +101,7 @@ declare class Tool {
      * Parse manual.md content
      * First line format: "tool_name: description", extract description
      * Remaining content is the manual
+     * If manual has content, prepend HAS_MANUAL symbol to description
      */
     static parseManual(content: string): {
         description: string;
@@ -96,7 +110,29 @@ declare class Tool {
     /**
      * Execute tool (with error handling and logging)
      */
-    run(args: Record<string, unknown>): Promise<ToolResultMsg>;
+    run(args: Record<string, unknown>): Promise<ToolResult>;
+}
+
+/**
+ * Procedure class - step-by-step guide for specific workflows
+ */
+declare class Procedure {
+    readonly name: string;
+    readonly description: string;
+    readonly manual: string;
+    constructor(config: {
+        name: string;
+        procedureContent: string;
+    });
+    /**
+     * Parse procedure.md content
+     * First line format: "procedure_name: description", extract description
+     * Remaining content is the procedure steps
+     */
+    static parseManual(content: string): {
+        description: string;
+        manual: string;
+    };
 }
 
 /**
@@ -207,6 +243,8 @@ declare let workingDir: string;
 declare function setWorkingDir(dir: string): void;
 /** 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 state */
@@ -214,29 +252,31 @@ declare function init(cwd?: string): Promise<void>;
 
 /**
  * Debug logging module
+ * All debug output is single-line for log-friendly format
  */
 /** Get debug mode status */
 declare function isDebugMode(): boolean;
 /** Set debug mode */
 declare function setDebugMode(enabled: boolean): void;
 /**
- * Debug log function
+ * Debug log function - single line output with timestamp
  * @param category Log category (e.g., 'API', 'Agent', 'Tool')
  * @param message Log message
- * @param data Optional additional data
+ * @param data Optional additional data (will be formatted to single line)
  */
 declare function debug(category: string, message: string, data?: unknown): void;
 
 /**
  * General logging module
+ * All log output is single-line with timestamp prefix
+ * Supports XML-style color tags: <red>text</red>, <bold>text</bold>, etc.
  */
-
 /**
- * Colored log output
- * @param color Color name
- * @param args Content to output
+ * Log output with timestamp and XML color tag support
+ * @param message Message string with optional XML color tags
+ * @example log('<yellow>[TOOL]</yellow> read_file <dim>{"path":"test.txt"}</dim>')
  */
-declare function log(color: ColorName, ...args: unknown[]): void;
+declare function log(message: string): void;
 /**
  * Info log
  */
@@ -257,6 +297,7 @@ declare function error(message: string): void;
 /**
  * Logging module
  * Provides debug mode and logging functionality
+ * Supports XML-style color tags: <red>text</red>, <bold>text</bold>, etc.
  */
 /**
  * Terminal colors and style definitions
@@ -279,6 +320,16 @@ declare const colors: {
 };
 /** Color name type */
 type ColorName = keyof typeof colors;
+/**
+ * Convert XML-style color tags to ANSI escape sequences
+ * Example: "<red>error</red>" -> "\x1b[31merror\x1b[0m"
+ */
+declare function convertColorTags(str: string): string;
+/**
+ * Create a buffered streaming color converter
+ * Used for streaming output where tags may span multiple chunks
+ */
+declare function createColorConverter(): (chunk: string) => string;
 
 declare class OpenAIAdapter extends Adapter {
     private client;
@@ -353,4 +404,4 @@ interface Model {
     readonly capabilities: ModelCapabilities;
 }
 
-export { AIMsg, Adapter, type AdapterResponse, Agent, type AgentResponse, type ColorName, MAX_COMPLETION_TOKENS, MODELS, type Model, type ModelCapabilities, type ModelProvider, Msg, MsgType, OpenAIAdapter, type ReasoningEffort$1 as ReasoningEffort, SystemMsg, TEMPERATURE, TOOLS, Tool, ToolCallMsg, ToolResultMsg, UserMsg, adapter, colors, config, debug, error, info, init, isDebugMode, log, setDebugMode, setWorkingDir, success, warn, workingDir };
+export { AIMsg, Adapter, type AdapterResponse, Agent, type AgentResponse, type ColorName, HAS_MANUAL, MAX_COMPLETION_TOKENS, MODELS, type Model, type ModelCapabilities, type ModelProvider, Msg, MsgType, OpenAIAdapter, PROCEDURES, type ReasoningEffort$1 as ReasoningEffort, SystemMsg, TEMPERATURE, TOOLS, Tool, type ToolCall, ToolCallMsg, type ToolResult, ToolResultMsg, UserMsg, adapter, colors, config, convertColorTags, createColorConverter, debug, error, info, init, isDebugMode, log, setDebugMode, setWorkingDir, success, warn, workingDir };

package/dist/index.js

@@ -166,19 +166,40 @@ var ToolCallMsg = class extends Msg {
     this.toolCalls = toolCalls;
   }
 };
-var ToolResultMsg = class extends Msg {
+var ToolResultMsg = class _ToolResultMsg extends Msg {
   type = "tool_result" /* ToolResult */;
-  toolName;
-  result;
-  isError;
-  constructor(toolName, result, isError) {
+  toolResults;
+  constructor(toolResults) {
     super("");
-    this.toolName = toolName;
-    this.result = result;
-    this.isError = isError;
+    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 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() {
@@ -187,43 +208,20 @@ function isDebugMode() {
 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 timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
-  const prefix = `${colors.gray}[${timestamp}]${colors.reset} ${colors.magenta}[DEBUG:${category}]${colors.reset}`;
-  console.log(`${prefix} ${colors.cyan}${message}${colors.reset}`);
-  if (data !== void 0) {
-    const dataStr = typeof data === "string" ? data : JSON.stringify(data, null, 2);
-    const lines = dataStr.split("\n");
-    const maxLines = 20;
-    const truncated = lines.length > maxLines;
-    const displayLines = truncated ? lines.slice(-maxLines) : lines;
-    if (truncated) {
-      console.log(colors.dim + `    ... (${lines.length - maxLines} earlier lines)` + colors.reset);
-    }
-    console.log(colors.dim + displayLines.map((l) => `    ${l}`).join("\n") + colors.reset);
-  }
-}
-
-// src/log/log.ts
-function log(color, ...args) {
-  console.log(colors[color], ...args, colors.reset);
-}
-function info(message) {
-  console.log(`${colors.blue}\u2139${colors.reset} ${message}`);
-}
-function success(message) {
-  console.log(`${colors.green}\u2714${colors.reset} ${message}`);
-}
-function warn(message) {
-  console.log(`${colors.yellow}\u26A0${colors.reset} ${message}`);
-}
-function error(message) {
-  console.log(`${colors.red}\u2716${colors.reset} ${message}`);
+  const dataStr = data !== void 0 ? ` <dim>${formatData(data)}</dim>` : "";
+  log(`<magenta>[${category}]</magenta> <cyan>${message}</cyan>${dataStr}`);
 }
 
 // src/log/index.ts
-var colors = {
+var colors2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -239,6 +237,33 @@ var colors = {
   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
 var OpenAIAdapter = class extends Adapter {
@@ -272,11 +297,13 @@ var OpenAIAdapter = class extends Adapter {
         });
       } else if (msg.type === "tool_result" /* ToolResult */) {
         const toolResultMsg = msg;
-        result.push({
-          role: "tool",
-          tool_call_id: pendingIds.shift() || `call_${msg.timestamp}`,
-          content: toolResultMsg.isError ? `Error: ${toolResultMsg.result}` : toolResultMsg.result
-        });
+        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;
@@ -298,7 +325,6 @@ var OpenAIAdapter = class extends Adapter {
   async chat(messages, onChunk) {
     debug("API", `Requesting OpenAI (model: ${this.model}, messages: ${messages.length})`);
     const openaiMessages = this.toOpenAIMessages(messages);
-    debug("API", "Sent prompt:", openaiMessages);
     const startTime = Date.now();
     const requestParams = {
       model: this.model,
@@ -358,6 +384,7 @@ function setWorkingDir(dir) {
   workingDir = dir;
 }
 var TOOLS = {};
+var PROCEDURES = {};
 var adapter = null;
 function initAdapter() {
   if (adapter) {
@@ -378,6 +405,7 @@ async function init(cwd) {
 }
 
 // src/tool/Tool.ts
+var HAS_MANUAL = "\u{1F4D8}";
 var Tool = class _Tool {
   name;
   description;
@@ -398,6 +426,7 @@ var Tool = class _Tool {
    * Parse manual.md content
    * First line format: "tool_name: description", extract description
    * Remaining content is the manual
+   * If manual has content, prepend HAS_MANUAL symbol to description
    */
   static parseManual(content) {
     const lines = content.split("\n");
@@ -408,28 +437,25 @@ var Tool = class _Tool {
       description = firstLine.slice(colonIndex + 1).trim();
     }
     const manual = lines.slice(1).join("\n").trim();
+    if (manual) {
+      description = `${HAS_MANUAL}${description}`;
+    }
     return { description, manual };
   }
   /**
    * Execute tool (with error handling and logging)
    */
   async run(args) {
-    debug("Tool", `Starting tool execution: ${this.name}`, args);
-    const startTime = Date.now();
     try {
       const result = await this._execute(args);
-      const elapsed = Date.now() - startTime;
       if (typeof result === "string") {
-        debug("Tool", `Tool execution successful: ${this.name} (elapsed: ${elapsed}ms, result length: ${result.length})`);
-        return new ToolResultMsg(this.name, result);
+        return { toolName: this.name, result };
       }
-      debug("Tool", `Tool execution completed: ${this.name} (elapsed: ${elapsed}ms, isError: ${result.isError || false})`);
-      return new ToolResultMsg(this.name, result.content, result.isError);
+      return { toolName: this.name, result: result.content, isError: result.isError };
     } catch (error2) {
-      const elapsed = Date.now() - startTime;
       const errorMsg = error2 instanceof Error ? error2.message : String(error2);
-      debug("Tool", `Tool execution failed: ${this.name} (elapsed: ${elapsed}ms)`, errorMsg);
-      return new ToolResultMsg(this.name, `Error: ${errorMsg}`, true);
+      debug("Tool", `${this.name} error`, errorMsg);
+      return { toolName: this.name, result: `Error: ${errorMsg}`, isError: true };
     }
   }
 };
@@ -439,7 +465,7 @@ import * as fs2 from "fs/promises";
 import * as path2 from "path";
 
 // src/tool/read_file/manual.md
-var manual_default = "read_file: Read the content of a specified file\n\n## Parameters\n\n- `path` (string, required): File path\n";
+var manual_default = "read_file: Read the content of a specified file\n";
 
 // src/tool/read_file/index.ts
 TOOLS["read_file"] = new Tool({
@@ -468,7 +494,7 @@ import * as fs3 from "fs/promises";
 import * as path3 from "path";
 
 // src/tool/write_file/manual.md
-var manual_default2 = "write_file: Write content to a specified file, create the file if it doesn't exist\n\n## Parameters\n\n- `path` (string, required): File path\n- `content` (string, required): Content to write\n";
+var manual_default2 = "write_file: Write content to a specified file, create the file if it doesn't exist\n";
 
 // src/tool/write_file/index.ts
 TOOLS["write_file"] = new Tool({
@@ -501,7 +527,7 @@ import * as fs4 from "fs/promises";
 import * as path4 from "path";
 
 // src/tool/list_directory/manual.md
-var manual_default3 = "list_directory: List files and subdirectories in a specified directory\n\n## Parameters\n\n- `path` (string, optional): Directory path, defaults to current directory\n";
+var manual_default3 = "list_directory: List files and subdirectories in a specified directory\n";
 
 // src/tool/list_directory/index.ts
 TOOLS["list_directory"] = new Tool({
@@ -566,12 +592,12 @@ ${stderr}`;
   }
 });
 
-// src/tool/get_tool_info/manual.md
-var manual_default5 = "get_tool_info: View detailed usage instructions for a specified tool\n\n## Parameters\n\n- `tool_name` (string, required): Tool name to view\n\n";
+// src/tool/read_tool_manual/manual.md
+var manual_default5 = "read_tool_manual: View detailed usage instructions for a specified tool\n";
 
-// src/tool/get_tool_info/index.ts
-TOOLS["get_tool_info"] = new Tool({
-  name: "get_tool_info",
+// src/tool/read_tool_manual/index.ts
+TOOLS["read_tool_manual"] = new Tool({
+  name: "read_tool_manual",
   parameters: {
     tool_name: { type: "string", description: "Tool name to view" }
   },
@@ -596,6 +622,76 @@ ${foundTool.manual}`;
   }
 });
 
+// src/tool/read_procedure/manual.md
+var manual_default6 = "read_procedure: View detailed steps for a specified procedure\n";
+
+// src/tool/read_procedure/index.ts
+TOOLS["read_procedure"] = new Tool({
+  name: "read_procedure",
+  parameters: {
+    procedure_name: { type: "string", description: "Procedure name to view" }
+  },
+  required: ["procedure_name"],
+  manualContent: manual_default6,
+  execute: async (args) => {
+    const procedureName = args.procedure_name;
+    const procedure = PROCEDURES[procedureName];
+    if (!procedure) {
+      const available = Object.keys(PROCEDURES).join(", ");
+      return {
+        content: `Procedure not found: ${procedureName}
+Available: ${available}`,
+        isError: true
+      };
+    }
+    return `# ${procedure.name}
+
+${procedure.description}
+
+## Steps
+
+${procedure.manual}`;
+  }
+});
+
+// src/procedure/Procedure.ts
+var Procedure = class _Procedure {
+  name;
+  description;
+  manual;
+  constructor(config2) {
+    this.name = config2.name;
+    const { description, manual } = _Procedure.parseManual(config2.procedureContent);
+    this.description = description;
+    this.manual = manual;
+  }
+  /**
+   * Parse procedure.md content
+   * First line format: "procedure_name: description", extract description
+   * Remaining content is the procedure steps
+   */
+  static parseManual(content) {
+    const lines = content.split("\n");
+    const firstLine = lines[0] || "";
+    let description = "";
+    const colonIndex = firstLine.indexOf(":");
+    if (colonIndex > 0) {
+      description = firstLine.slice(colonIndex + 1).trim();
+    }
+    const manual = lines.slice(1).join("\n").trim();
+    return { description, manual };
+  }
+};
+
+// src/procedure/understand_project/procedure.md
+var procedure_default = "understand_project: Systematically explore and understand the current project structure\n\n1. Use `list_directory` on the root directory to get an overview\n   - Identify key directories (src, lib, tests, docs, etc.)\n   - Note configuration files (package.json, tsconfig.json, Cargo.toml, etc.)\n\n2. Use `read_file` on the main configuration file (package.json, Cargo.toml, pyproject.toml, etc.)\n   - Project name and description\n   - Dependencies and their purposes\n   - Scripts/commands available\n   - Entry points\n\n3. Use `read_file` on README.md if it exists\n   - Project purpose and goals\n   - Setup instructions\n   - Usage examples\n\n4. Use `list_directory` on the main source directory (src/, lib/, app/, etc.)\n   - Identify the entry point file (index.ts, main.ts, app.ts, etc.)\n   - List subdirectories to understand module organization\n   - Note any patterns (MVC, feature-based, etc.)\n\n5. Use `read_file` on 2-3 key source files to understand\n   - Coding style and conventions\n   - Main abstractions and patterns used\n   - How modules interact with each other\n\n6. Output the final report in this format **in user's language**:\n\n---\n<bold><cyan>Project Overview</cyan></bold>\n\nName: [project name]\nType: [CLI tool / Web app / Library / API server / etc.]\nLanguage: [TypeScript / JavaScript / Python / etc.]\nPackage Manager: [npm / pnpm / yarn / pip / cargo / etc.]\n\n<bold><cyan>Project Structure</cyan></bold>\n\n[Brief description of directory structure and organization pattern]\n\n<bold><cyan>Key Components</cyan></bold>\n\n\u2022 [Component 1]: [brief description]\n\u2022 [Component 2]: [brief description]\n\u2022 [Component 3]: [brief description]\n...\n\n<bold><cyan>Entry Points</cyan></bold>\n\n\u2022 Main: [path to main entry]\n\u2022 CLI: [path to CLI entry if applicable]\n\u2022 Tests: [path to test entry if applicable]\n\n<bold><cyan>Dependencies</cyan></bold>\n\nCore:\n\u2022 [dep1]: [purpose]\n\u2022 [dep2]: [purpose]\n\nDev:\n\u2022 [dev-dep1]: [purpose]\n\u2022 [dev-dep2]: [purpose]\n\n<bold><cyan>Available Commands</cyan></bold>\n\n\u2022 [command1]: [description]\n\u2022 [command2]: [description]\n...\n\n<bold><cyan>Code Patterns</cyan></bold>\n\n\u2022 [Pattern 1 observed in the codebase]\n\u2022 [Pattern 2 observed in the codebase]\n...\n---\n";
+
+// src/procedure/understand_project/index.ts
+PROCEDURES["understand_project"] = new Procedure({
+  name: "understand_project",
+  procedureContent: procedure_default
+});
+
 // src/model/models.ts
 var MODELS = {
   "gpt-5.2": {
@@ -686,23 +782,20 @@ var Agent = class {
       const toolCalls = toolCallMsg.toolCalls;
       debug("Agent", `Received tool call request`, toolCalls.map((tc) => tc.name));
       this.config.onToolCallMsg?.(toolCallMsg);
+      const toolResults = [];
       for (const tc of toolCalls) {
         this.config.onBeforeToolRun?.(tc.name, tc.arguments);
-        debug("Agent", `Executing tool: ${tc.name}`, tc.arguments);
         const tool = TOOLS[tc.name];
-        const result = tool ? await tool.run(tc.arguments) : new ToolResultMsg(tc.name, `Unknown tool: ${tc.name}`, true);
-        debug("Agent", `Tool execution completed: ${tc.name}`, {
-          isError: result.isError,
-          contentLength: result.result.length
-        });
+        const result = tool ? await tool.run(tc.arguments) : { toolName: tc.name, result: `Unknown tool: ${tc.name}`, isError: true };
         toolCallHistory.push({
           name: tc.name,
           arguments: tc.arguments,
           result: result.result
         });
         this.config.onToolResult?.(tc.name, tc.arguments, result.result);
-        this.messages.push(result);
+        toolResults.push(result);
       }
+      this.messages.push(new ToolResultMsg(toolResults));
     }
   }
   reset() {
@@ -711,48 +804,20 @@ var Agent = class {
   }
 };
 
-// src/agent/main/colors.ts
-var tagNames = Object.keys(colors).filter((k) => k !== "reset").join("|");
-var tagRegex = new RegExp(`<(\\/?)(${tagNames})>`, "gi");
-function convertColorTags(str) {
-  return str.replace(tagRegex, (_, closing, tag) => {
-    return closing ? colors.reset : colors[tag.toLowerCase()] || "";
-  });
-}
-function createColorConverter() {
-  let buffer = "";
-  return (chunk) => {
-    buffer += chunk;
-    const lastOpen = buffer.lastIndexOf("<");
-    if (lastOpen === -1) {
-      const out2 = convertColorTags(buffer);
-      buffer = "";
-      return out2;
-    }
-    if (buffer.indexOf(">", lastOpen) !== -1) {
-      const out2 = convertColorTags(buffer);
-      buffer = "";
-      return out2;
-    }
-    const out = convertColorTags(buffer.slice(0, lastOpen));
-    buffer = buffer.slice(lastOpen);
-    return out;
-  };
-}
-
-// src/agent/main/system.md
-var system_default = "You are Arki, a professional AI programming assistant. You work in the codebase directory `{{working_dir}}`.\n\n## Available Tools\n\n{{tools}}\n\nTools can be called multiple times at once. Make good use of this to improve efficiency.\nIf you need to understand the detailed usage of a tool, use the `get_tool_info` tool to view it.\n\n## Working Principles\n\n1. **Accuracy**: Before answering questions, use tools to view relevant code first. Don't base statements on assumptions. If you don't know something, just admit it - it's no big deal.\n2. **Safety**: Consider potential risks before executing commands.\n3. **Conciseness**: Keep answers brief and concise, avoid repetition and redundancy. Keep each response within 200 words unless the user requests detailed explanation.\n4. **Proactivity**: Actively suggest improvements when you find issues.\n\n## Response Style\n\n- Answer questions directly, avoid excessive pleasantries\n- Don't use emojis\n- Don't repeatedly ask about user needs, once is enough. Don't ask and answer yourself.\n\nThe user is talking to you via **CLI terminal**. **Do not** output Markdown. Use numbered lists for ordered lists, and \u2022 symbol for unordered lists.\nUse the following tags to format output:\n\n| Scenario | Format |\n|----------|--------|\n| Error/Danger | `<red>...</red>` |\n| Warning/Notice | `<yellow>...</yellow>` |\n| Success/Complete | `<green>...</green>` |\n| File path | `<cyan>...</cyan>` |\n| Code/Command | `<dim>...</dim>` |\n| Emphasis | `<bold>...</bold>` |\n\nTags can be combined, e.g., `<bold><red>Critical Error</red></bold>`\n\nPlease answer questions in the language the user is using, and flexibly use available tools to complete tasks.\n";
+// src/agent/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/main/main.ts
+// src/agent/Arki/Arki.ts
+var toolStartTimes = /* @__PURE__ */ new Map();
 function createMainAgent() {
   if (!adapter) {
     throw new Error("Adapter not initialized, please call init() first");
   }
-  const toolDescriptions = Object.values(TOOLS).map((t) => `${t.name}: ${t.description}`).join("\n");
+  const proceduresList = Object.values(PROCEDURES).map((p) => `- ${p.name}: ${p.description}`).join("\n");
   const systemInstruction = Agent.renderTemplate(system_default, {
     working_dir: workingDir,
-    current_time: (/* @__PURE__ */ new Date()).toLocaleString(),
-    tools: toolDescriptions
+    has_manual: HAS_MANUAL,
+    procedures: proceduresList || "(none)"
   });
   const convertColor = createColorConverter();
   const agent = new Agent({
@@ -761,19 +826,31 @@ function createMainAgent() {
     onStream: (chunk) => {
       process.stdout.write(convertColor(chunk));
     },
-    onBeforeToolRun: (name, args) => {
-      const argsStr = JSON.stringify(args);
-      const argsPreview = argsStr.length > 60 ? argsStr.substring(0, 60) + "..." : argsStr;
-      process.stdout.write(`\x1B[33m\u{1F527} ${name}\x1B[0m \x1B[2m${argsPreview}\x1B[0m`);
+    onBeforeToolRun: (name) => {
+      toolStartTimes.set(name, Date.now());
     },
     onToolResult: (name, args, result) => {
+      const startTime = toolStartTimes.get(name) || Date.now();
+      const elapsed = Date.now() - startTime;
+      toolStartTimes.delete(name);
       const argsStr = JSON.stringify(args);
       const argsPreview = argsStr.length > 60 ? argsStr.substring(0, 60) + "..." : argsStr;
-      const resultPreview = result.length > 80 ? result.substring(0, 80) + "..." : result;
-      const firstLine = resultPreview.split("\n")[0];
-      process.stdout.write(`\r\x1B[2K\x1B[32m\u2714 ${name}\x1B[0m \x1B[2m${argsPreview}\x1B[0m
-`);
-      log("dim", `   ${firstLine}`);
+      let output = `<green>[TOOL]</green> ${name} <dim>${argsPreview} (${elapsed}ms)`;
+      if (isDebugMode()) {
+        const lines = result.split("\n").filter((l) => l.trim());
+        let summary;
+        if (lines.length <= 3) {
+          summary = lines.join(", ");
+          if (summary.length > 60) summary = summary.substring(0, 60) + "...";
+        } else {
+          const preview = lines.slice(0, 3).join(", ");
+          summary = preview.length > 50 ? preview.substring(0, 50) + "..." : preview;
+          summary += ` (+${lines.length - 3} more)`;
+        }
+        output += ` -> ${summary}`;
+      }
+      output += "</dim>";
+      log(output);
     }
   });
   return agent;
@@ -782,7 +859,7 @@ function createMainAgent() {
 // package.json
 var package_default = {
   name: "arki",
-  version: "0.0.3",
+  version: "0.0.5",
   description: "AI Agent Programming Assistant",
   type: "module",
   main: "dist/index.js",
@@ -890,15 +967,15 @@ async function main() {
   const mainAgentConfig = config.getAgentConfig("main");
   const model = MODELS[mainAgentConfig.model];
   console.log();
-  log("cyan", `Arki AI Agent v${package_default.version}`);
+  log(`<cyan>Arki AI Agent v${package_default.version}</cyan>`);
   console.log();
-  log("dim", `Model: ${mainAgentConfig.model}${model ? ` (${model.name})` : ""}`);
-  log("dim", `Working directory: ${workingDir}`);
+  log(`<dim>Model: ${mainAgentConfig.model}${model ? ` (${model.name})` : ""}</dim>`);
+  log(`<dim>Working directory: ${workingDir}</dim>`);
   if (isDebugMode()) {
-    log("yellow", `\u{1F41B} Debug mode enabled`);
+    log(`<yellow>Debug mode enabled</yellow>`);
   }
   console.log();
-  log("dim", `Loaded ${Object.keys(TOOLS).length} tools`);
+  log(`<dim>Loaded ${Object.keys(TOOLS).length} tools</dim>`);
   if (isDebugMode()) {
     debug("Init", "Loaded tools", Object.keys(TOOLS));
     debug("Init", "Agent config", mainAgentConfig);
@@ -909,38 +986,39 @@ async function main() {
     input: process.stdin,
     output: process.stdout
   });
-  log("blue", "Enter your question and press Enter to send. Type /exit or /quit to exit.");
-  log("blue", "Type /clear to clear conversation history.");
+  log(`<blue>Enter your question and press Enter to send. Type /exit or /quit to exit.</blue>`);
+  log(`<blue>Type /clear to clear conversation history.</blue>`);
   console.log();
+  const promptStr = convertColorTags("<green>> </green>");
   const prompt = () => {
-    rl.question(`${colors.green}> ${colors.reset}`, async (input) => {
+    rl.question(promptStr, async (input) => {
       const trimmed = input.trim();
       if (trimmed === "/exit" || trimmed === "/quit") {
-        log("cyan", "Goodbye!");
+        log(`<cyan>Goodbye!</cyan>`);
         rl.close();
         process.exit(0);
       }
       if (trimmed === "/clear") {
         agent.reset();
-        log("yellow", "Conversation history cleared");
+        log(`<yellow>Conversation history cleared</yellow>`);
         console.log();
         prompt();
         return;
       }
       if (trimmed === "/help") {
         console.log();
-        log("cyan", "Available commands:");
-        log("dim", "  /exit, /quit  - Exit program");
-        log("dim", "  /clear        - Clear conversation history");
-        log("dim", "  /debug        - Toggle debug mode");
-        log("dim", "  /help         - Show help");
+        log(`<cyan>Available commands:</cyan>`);
+        log(`<dim>  /exit, /quit  - Exit program</dim>`);
+        log(`<dim>  /clear        - Clear conversation history</dim>`);
+        log(`<dim>  /debug        - Toggle debug mode</dim>`);
+        log(`<dim>  /help         - Show help</dim>`);
         console.log();
         prompt();
         return;
       }
       if (trimmed === "/debug") {
         setDebugMode(!isDebugMode());
-        log("yellow", `Debug mode ${isDebugMode() ? "enabled \u{1F41B}" : "disabled"}`);
+        log(`<yellow>Debug mode ${isDebugMode() ? "enabled" : "disabled"}</yellow>`);
         console.log();
         prompt();
         return;
@@ -955,14 +1033,11 @@ async function main() {
         console.log();
         if (result.usage) {
           const contextLimit = model?.capabilities.contextWindow || "N/A";
-          log(
-            "dim",
-            `[Tokens: ${result.usage.totalTokens} (prompt: ${result.usage.promptTokens}, cached: ${result.usage.cachedTokens || 0}, limit: ${contextLimit})]`
-          );
+          log(`<dim>[Tokens: ${result.usage.totalTokens} (prompt: ${result.usage.promptTokens}, cached: ${result.usage.cachedTokens || 0}, limit: ${contextLimit})]</dim>`);
         }
         console.log();
       } catch (error2) {
-        log("red", `Error: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        log(`<red>Error: ${error2 instanceof Error ? error2.message : String(error2)}</red>`);
         console.log();
       }
       prompt();
@@ -978,11 +1053,13 @@ export {
   AIMsg,
   Adapter,
   Agent,
+  HAS_MANUAL,
   MAX_COMPLETION_TOKENS,
   MODELS,
   Msg,
   MsgType,
   OpenAIAdapter,
+  PROCEDURES,
   SystemMsg,
   TEMPERATURE,
   TOOLS,
@@ -991,8 +1068,10 @@ export {
   ToolResultMsg,
   UserMsg,
   adapter,
-  colors,
+  colors2 as colors,
   config,
+  convertColorTags,
+  createColorConverter,
   debug,
   error,
   info,

package/package.json

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