@aman_asmuei/aman-agent 0.17.1 → 0.17.2

package/dist/index.js

@@ -232,7 +232,7 @@ function toAnthropicMessages(messages) {
 function createAnthropicClient(apiKey, model) {
   const client = new Anthropic({ apiKey });
   return {
-    async chat(systemPrompt, messages, onChunk, tools) {
+    async chat(systemPrompt, messages, onChunk, tools, options) {
       const anthropicMessages = toAnthropicMessages(messages);
       const hasTools = tools && tools.length > 0;
       try {
@@ -242,7 +242,7 @@ function createAnthropicClient(apiKey, model) {
         let currentBlockIndex = -1;
         const createParams = {
           model,
-          max_tokens: 8192,
+          max_tokens: options?.maxOutputTokens ?? 8192,
           system: systemPrompt,
           messages: anthropicMessages,
           stream: true
@@ -330,7 +330,9 @@ function createAnthropicClient(apiKey, model) {
 
 // src/llm/openai.ts
 import OpenAI from "openai";
-function toOpenAIMessages(systemPrompt, messages) {
+
+// src/llm/openai-compat.ts
+function toOpenAICompatibleMessages(systemPrompt, messages) {
   const result = [
     { role: "system", content: systemPrompt }
   ];
@@ -398,18 +400,20 @@ function toOpenAIMessages(systemPrompt, messages) {
   }
   return result;
 }
+
+// src/llm/openai.ts
 function createOpenAIClient(apiKey, model) {
   const client = new OpenAI({ apiKey });
   return {
-    async chat(systemPrompt, messages, onChunk, tools) {
-      const openaiMessages = toOpenAIMessages(systemPrompt, messages);
+    async chat(systemPrompt, messages, onChunk, tools, options) {
+      const openaiMessages = toOpenAICompatibleMessages(systemPrompt, messages);
       const hasTools = tools && tools.length > 0;
       try {
         let fullText = "";
         const toolCallAccumulators = /* @__PURE__ */ new Map();
         const createParams = {
           model,
-          max_tokens: 8192,
+          max_tokens: options?.maxOutputTokens ?? 8192,
           messages: openaiMessages,
           stream: true
         };
@@ -495,74 +499,6 @@ function createOpenAIClient(apiKey, model) {
 
 // src/llm/ollama.ts
 import OpenAI2 from "openai";
-function toOllamaMessages(systemPrompt, messages) {
-  const result = [
-    { role: "system", content: systemPrompt }
-  ];
-  for (const m of messages) {
-    if (typeof m.content === "string") {
-      result.push({
-        role: m.role,
-        content: m.content
-      });
-    } else if (m.role === "assistant") {
-      const textParts = m.content.filter((b) => b.type === "text");
-      const toolUseParts = m.content.filter((b) => b.type === "tool_use");
-      const text2 = textParts.map((b) => "text" in b ? b.text : "").join("");
-      if (toolUseParts.length > 0) {
-        result.push({
-          role: "assistant",
-          content: text2 || null,
-          tool_calls: toolUseParts.map((b) => ({
-            id: "id" in b ? b.id : "",
-            type: "function",
-            function: {
-              name: "name" in b ? b.name : "",
-              arguments: JSON.stringify("input" in b ? b.input : {})
-            }
-          }))
-        });
-      } else {
-        result.push({ role: "assistant", content: text2 });
-      }
-    } else if (m.role === "user") {
-      const toolResults = m.content.filter((b) => b.type === "tool_result");
-      if (toolResults.length > 0) {
-        for (const tr of toolResults) {
-          if (tr.type === "tool_result") {
-            result.push({
-              role: "tool",
-              tool_call_id: tr.tool_use_id,
-              content: tr.content
-            });
-          }
-        }
-      } else {
-        const hasImages = m.content.some((b) => b.type === "image");
-        if (hasImages) {
-          const parts = [];
-          for (const b of m.content) {
-            if (b.type === "text") {
-              parts.push({ type: "text", text: b.text });
-            } else if (b.type === "image") {
-              parts.push({
-                type: "image_url",
-                image_url: {
-                  url: `data:${b.source.media_type};base64,${b.source.data}`
-                }
-              });
-            }
-          }
-          result.push({ role: "user", content: parts });
-        } else {
-          const text2 = m.content.map((b) => "text" in b ? b.text : "").join("");
-          result.push({ role: "user", content: text2 });
-        }
-      }
-    }
-  }
-  return result;
-}
 function createOllamaClient(model, baseURL) {
   const client = new OpenAI2({
     baseURL: baseURL || "http://localhost:11434/v1",
@@ -570,15 +506,15 @@ function createOllamaClient(model, baseURL) {
     // Ollama doesn't require a real key
   });
   return {
-    async chat(systemPrompt, messages, onChunk, tools) {
-      const ollamaMessages = toOllamaMessages(systemPrompt, messages);
+    async chat(systemPrompt, messages, onChunk, tools, options) {
+      const ollamaMessages = toOpenAICompatibleMessages(systemPrompt, messages);
       const hasTools = tools && tools.length > 0;
       try {
         let fullText = "";
         const toolCallAccumulators = /* @__PURE__ */ new Map();
         const createParams = {
           model,
-          max_tokens: 8192,
+          max_tokens: options?.maxOutputTokens ?? 4096,
           messages: ollamaMessages,
           stream: true
         };
@@ -730,12 +666,18 @@ async function withRetry(fn, options) {
 }
 
 // src/mcp/client.ts
+var TOOL_CALL_TIMEOUT_MS = 3e4;
 var McpManager = class {
   connections = [];
   tools = [];
-  async connect(name, command, args) {
+  async connect(name, command, args, env) {
     try {
-      const transport = new StdioClientTransport({ command, args, stderr: "pipe" });
+      const transport = new StdioClientTransport({
+        command,
+        args,
+        stderr: "pipe",
+        env: env ? env : void 0
+      });
       const client = new Client({
         name: `aman-agent-${name}`,
         version: "0.1.0"
@@ -746,9 +688,16 @@ var McpManager = class {
           log.debug("mcp", `[${name} stderr] ${chunk.toString().trim()}`);
         });
       }
-      this.connections.push({ name, client, transport });
+      this.connections.push({ name, client, transport, connectParams: { command, args, env } });
       const toolsResult = await client.listTools();
       for (const tool of toolsResult.tools) {
+        const existing = this.tools.find((t) => t.name === tool.name);
+        if (existing) {
+          log.warn(
+            "mcp",
+            `Warning: tool "${tool.name}" from server "${name}" shadows existing tool from "${existing.serverName}"`
+          );
+        }
         this.tools.push({
           name: tool.name,
           description: tool.description || "",
@@ -771,7 +720,15 @@ var McpManager = class {
     if (!conn) return `Error: server ${tool.serverName} not connected`;
     try {
       const result = await withRetry(
-        () => conn.client.callTool({ name: toolName, arguments: args }),
+        () => Promise.race([
+          conn.client.callTool({ name: toolName, arguments: args }),
+          new Promise(
+            (_, reject) => setTimeout(
+              () => reject(new Error(`Tool ${toolName} timed out after 30s`)),
+              TOOL_CALL_TIMEOUT_MS
+            )
+          )
+        ]),
         { maxAttempts: 2, baseDelay: 500, retryable: (err) => err.message.includes("ETIMEDOUT") || err.message.includes("timeout") }
       );
       if (result.content && Array.isArray(result.content)) {
@@ -782,6 +739,23 @@ var McpManager = class {
       return `Error calling ${toolName}: ${error instanceof Error ? error.message : String(error)}`;
     }
   }
+  async reconnect(name) {
+    const connIndex = this.connections.findIndex((c) => c.name === name);
+    if (connIndex === -1) {
+      log.error("mcp", `Cannot reconnect: no connection found for "${name}"`);
+      return;
+    }
+    const conn = this.connections[connIndex];
+    const { command, args, env } = conn.connectParams;
+    try {
+      await conn.client.close();
+    } catch (err) {
+      log.debug("mcp", `Error closing old connection for ${name}`, err);
+    }
+    this.connections.splice(connIndex, 1);
+    this.tools = this.tools.filter((t) => t.serverName !== name);
+    await this.connect(name, command, args, env);
+  }
   async disconnect() {
     for (const conn of this.connections) {
       try {
@@ -893,7 +867,27 @@ async function initMemory(project) {
   const amemDir = process.env.AMEM_DIR ?? path5.join(os5.homedir(), ".amem");
   if (!fs5.existsSync(amemDir)) fs5.mkdirSync(amemDir, { recursive: true });
   const dbPath = process.env.AMEM_DB ?? path5.join(amemDir, "memory.db");
-  db = createDatabase(dbPath);
+  try {
+    db = createDatabase(dbPath);
+  } catch (err) {
+    const backupPath = `${dbPath}.corrupt.${Date.now()}`;
+    try {
+      if (fs5.existsSync(dbPath)) {
+        fs5.renameSync(dbPath, backupPath);
+        if (fs5.existsSync(`${dbPath}-wal`)) fs5.unlinkSync(`${dbPath}-wal`);
+        if (fs5.existsSync(`${dbPath}-shm`)) fs5.unlinkSync(`${dbPath}-shm`);
+        console.error(`[amem] Database corrupted \u2014 backed up to ${backupPath}`);
+        console.error("[amem] Creating fresh database. Previous memories are in the backup file.");
+        db = createDatabase(dbPath);
+      } else {
+        throw err;
+      }
+    } catch {
+      console.error(`[amem] Failed to initialize memory: ${err instanceof Error ? err.message : String(err)}`);
+      console.error(`[amem] Try deleting ${amemDir} to reset: rm -rf ${amemDir}`);
+      throw err;
+    }
+  }
   currentProject = project ?? "global";
   preloadEmbeddings();
   setTimeout(() => {
@@ -974,12 +968,19 @@ async function memoryForget(opts) {
   }
   return { deleted: 0, message: "Provide an id, type, or query to forget." };
 }
+var memoryConfig = {};
+function setMemoryConfig(config) {
+  memoryConfig = config;
+}
+function getMaxRecallTokens() {
+  return memoryConfig.maxRecallTokens ?? 1500;
+}
 function memoryConsolidate(dryRun = false) {
   return consolidateMemories(getDb(), cosineSimilarity, {
     dryRun,
-    maxStaleDays: 90,
-    minConfidence: 0.3,
-    minAccessCount: 0
+    maxStaleDays: memoryConfig.maxStaleDays ?? 90,
+    minConfidence: memoryConfig.minConfidence ?? 0.3,
+    minAccessCount: memoryConfig.minAccessCount ?? 0
   });
 }
 function isMemoryInitialized() {
@@ -2136,7 +2137,7 @@ async function handleMemoryCommand(action, args, ctx) {
     }
     try {
       if (args[0] === "--type" && args[1]) {
-        const result2 = await memoryForget({ query: args[1], type: args[1] });
+        const result2 = await memoryForget({ type: args[1] });
         return { handled: true, output: result2.deleted > 0 ? pc3.green(result2.message) : pc3.dim(result2.message) };
       }
       const result = await memoryForget({ query: args.join(" ") });
@@ -2378,6 +2379,10 @@ function handleHelp() {
       `  ${pc3.cyan("/debug")}        Show debug log`,
       `  ${pc3.cyan("/save")}         Save conversation to memory`,
       `  ${pc3.cyan("/model")}        Show current LLM model`,
+      `  ${pc3.cyan("/plan")}         Manage multi-step plans`,
+      `  ${pc3.cyan("/profile")}      Switch agent profiles`,
+      `  ${pc3.cyan("/delegate")}     Delegate tasks to sub-agents`,
+      `  ${pc3.cyan("/team")}         Manage agent teams`,
       `  ${pc3.cyan("/update")}       Check for updates`,
       `  ${pc3.cyan("/reset")}       Full reset [all|memory|config|identity|rules]`,
       `  ${pc3.cyan("/clear")}        Clear conversation history`,
@@ -2443,7 +2448,7 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = JSON.parse(fs9.readFileSync(path9.join(__dirname, "..", "package.json"), "utf-8")).version;
+    const local = true ? "0.17.2" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc3.green("Up to date")} \u2014 v${local}` };
     }
@@ -4017,8 +4022,8 @@ Rules:
 - Be conservative \u2014 90% of turns produce nothing worth storing
 - Return ONLY the JSON array, no other text`;
 function shouldExtract(assistantResponse, turnsSinceLastExtraction, lastExtractionCount) {
-  if (lastExtractionCount > 0) return true;
   if (assistantResponse.length < MIN_RESPONSE_LENGTH) return false;
+  if (lastExtractionCount > 0 && turnsSinceLastExtraction >= 1) return true;
   if (turnsSinceLastExtraction < MIN_TURNS_BETWEEN_EMPTY) return false;
   return true;
 }
@@ -4333,13 +4338,20 @@ async function recallForMessage(input) {
       return null;
     }
     const tokenEstimate = result.tokenEstimate ?? Math.round(result.text.split(/\s+/).filter(Boolean).length * 1.3);
+    const MAX_MEMORY_TOKENS = getMaxRecallTokens();
+    let memoryText = result.text;
+    if (tokenEstimate > MAX_MEMORY_TOKENS) {
+      const maxChars = MAX_MEMORY_TOKENS * 4;
+      memoryText = memoryText.slice(0, maxChars) + "\n[... memory truncated to fit token budget]";
+      log.debug("agent", `memory recall truncated from ~${tokenEstimate} to ~${MAX_MEMORY_TOKENS} tokens`);
+    }
     return {
       text: `
 
 <relevant-memories>
-${result.text}
+${memoryText}
 </relevant-memories>`,
-      tokenEstimate
+      tokenEstimate: Math.min(tokenEstimate, MAX_MEMORY_TOKENS)
     };
   } catch (err) {
     log.debug("agent", "memory recall failed", err);
@@ -4395,7 +4407,7 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager,
     shownHints: loadShownHints(),
     hintShownThisSession: false
   };
-  const isRetryable2 = (err) => err.message.includes("Rate limit") || err.message.includes("rate limit") || err.message.includes("ECONNRESET") || err.message.includes("ETIMEDOUT") || err.message.includes("fetch failed");
+  const isRetryable2 = (err) => err.message.includes("Rate limit") || err.message.includes("rate limit") || err.message.includes("ECONNRESET") || err.message.includes("ETIMEDOUT") || err.message.includes("fetch failed") || err.message.includes("socket hang up") || err.message.includes("network socket disconnected") || err.message.includes("ENOTFOUND") || err.message.includes("EAI_AGAIN");
   let responseBuffer = "";
   const onChunkHandler = (chunk) => {
     if (chunk.type === "text" && chunk.text) {
@@ -4813,7 +4825,18 @@ ${converted}
         { maxAttempts: 3, baseDelay: 1e3, retryable: isRetryable2 }
       );
       messages.push(response.message);
+      const MAX_TOOL_TURNS = 20;
+      let toolTurnCount = 0;
       while (response.toolUses.length > 0 && mcpManager) {
+        toolTurnCount++;
+        if (toolTurnCount > MAX_TOOL_TURNS) {
+          messages.push({
+            role: "assistant",
+            content: "Tool execution limit reached (20). Breaking to prevent infinite loop."
+          });
+          console.log(pc6.yellow("\n  Tool execution limit reached (20). Breaking to prevent infinite loop."));
+          break;
+        }
         const toolResults = await Promise.all(
           response.toolUses.map(async (toolUse) => {
             if (hooksConfig) {
@@ -5128,10 +5151,22 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\n"), "utf-8");
   }
+  const flowDir = path14.join(home2, ".aflow");
+  const flowPath = path14.join(flowDir, "flow.md");
+  if (!fs14.existsSync(flowPath)) {
+    fs14.mkdirSync(flowDir, { recursive: true });
+    fs14.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
+  }
+  const skillDir = path14.join(home2, ".askill");
+  const skillPath = path14.join(skillDir, "skills.md");
+  if (!fs14.existsSync(skillPath)) {
+    fs14.mkdirSync(skillDir, { recursive: true });
+    fs14.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
+  }
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.17.1").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
+program.name("aman-agent").description("Your AI companion, running locally").version("0.17.2").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
   p2.intro(pc7.bold("aman agent") + pc7.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -5258,6 +5293,7 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
     }
   }
   const aiName = getProfileAiName(profile);
+  if (config.memory) setMemoryConfig(config.memory);
   try {
     await initMemory();
   } catch (err) {
@@ -5281,13 +5317,16 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   const mcpManager = new McpManager();
   const mcpSpinner = p2.spinner();
   mcpSpinner.start("Connecting to MCP servers");
-  await mcpManager.connect("aman", "npx", ["-y", "@aman_asmuei/aman-mcp"]);
+  const connections = [
+    mcpManager.connect("aman", "npx", ["-y", "@aman_asmuei/aman-mcp"])
+  ];
   if (config.mcpServers) {
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
       if (name === "aman" || name === "amem") continue;
-      await mcpManager.connect(name, serverConfig.command, serverConfig.args);
+      connections.push(mcpManager.connect(name, serverConfig.command, serverConfig.args, serverConfig.env));
     }
   }
+  await Promise.all(connections);
   const mcpTools = mcpManager.getTools();
   mcpSpinner.stop("MCP connected");
   if (mcpTools.length > 0) {