@aman_asmuei/aman-agent 0.5.0 → 0.6.0

package/dist/index.js

@@ -14,7 +14,8 @@ var DEFAULT_HOOKS = {
   workflowSuggest: true,
   evalPrompt: true,
   autoSessionSave: true,
-  extractMemories: true
+  extractMemories: true,
+  featureHints: true
 };
 var CONFIG_DIR = path.join(os.homedir(), ".aman-agent");
 var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
@@ -593,10 +594,13 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs6 from "fs";
-import path6 from "path";
-import os6 from "os";
+import fs7 from "fs";
+import path7 from "path";
+import os7 from "os";
 import pc3 from "picocolors";
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+import logUpdate from "log-update";
 
 // src/commands.ts
 import fs5 from "fs";
@@ -858,7 +862,56 @@ async function handleMemoryCommand(action, args, ctx) {
     const output = await mcpWrite(ctx, "memory", "memory_forget", { category: args[0] });
     return { handled: true, output };
   }
-  return { handled: true, output: pc.yellow(`Unknown action: /memory ${action}. Use /memory [search|clear].`) };
+  if (action === "timeline") {
+    if (!ctx.mcpManager) {
+      return { handled: true, output: pc.red("Memory not available: MCP not connected.") };
+    }
+    try {
+      const result = await ctx.mcpManager.callTool("memory_recall", { query: "*", limit: 500 });
+      if (result.startsWith("Error") || result.includes("No memories found")) {
+        return { handled: true, output: pc.dim("No memories yet. Start chatting and I'll remember what matters.") };
+      }
+      try {
+        const memories = JSON.parse(result);
+        if (Array.isArray(memories) && memories.length > 0) {
+          const byDate = /* @__PURE__ */ new Map();
+          for (const mem of memories) {
+            const date = mem.created_at ? new Date(mem.created_at).toLocaleDateString("en-US", { month: "short", day: "numeric" }) : "Unknown";
+            byDate.set(date, (byDate.get(date) || 0) + 1);
+          }
+          const maxCount = Math.max(...byDate.values());
+          const barWidth = 10;
+          const lines = [pc.bold("Memory Timeline:"), ""];
+          for (const [date, count] of byDate) {
+            const filled = Math.round(count / maxCount * barWidth);
+            const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+            lines.push(`  ${date.padEnd(8)} ${bar}  ${count} memories`);
+          }
+          const tags = /* @__PURE__ */ new Map();
+          for (const mem of memories) {
+            if (Array.isArray(mem.tags)) {
+              for (const tag of mem.tags) {
+                tags.set(tag, (tags.get(tag) || 0) + 1);
+              }
+            }
+          }
+          lines.push("");
+          lines.push(`  Total: ${memories.length} memories`);
+          if (tags.size > 0) {
+            const topTags = [...tags.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([tag, count]) => `#${tag} (${count})`).join(", ");
+            lines.push(`  Top tags: ${topTags}`);
+          }
+          return { handled: true, output: lines.join("\n") };
+        }
+      } catch {
+      }
+      const lineCount = result.split("\n").filter((l) => l.trim()).length;
+      return { handled: true, output: `Total memories: ~${lineCount} entries.` };
+    } catch {
+      return { handled: true, output: pc.red("Failed to retrieve memory timeline.") };
+    }
+  }
+  return { handled: true, output: pc.yellow(`Unknown action: /memory ${action}. Use /memory [search|clear|timeline].`) };
 }
 function handleStatusCommand(ctx) {
   const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
@@ -881,15 +934,45 @@ function handleDoctorCommand(ctx) {
   const amemConnected = mcpToolCount > 0;
   const status = getEcosystemStatus(mcpToolCount, amemConnected);
   const lines = [pc.bold("Aman Health Check"), ""];
+  let healthy = 0;
+  let fixes = 0;
+  let suggestions = 0;
   for (const layer of status.layers) {
-    const check = layer.exists ? pc.green("\u2713") : pc.red("\u2717");
-    const name = layer.name.padEnd(12);
-    const detail = layer.exists ? pc.green(layer.summary) : pc.red("missing");
-    lines.push(`  ${check} ${name} ${detail}`);
+    if (layer.exists) {
+      lines.push(`  ${pc.green("\u2713")} ${layer.name.padEnd(12)} ${pc.green(layer.summary)}`);
+      healthy++;
+    } else {
+      const isRequired = ["identity", "rules"].includes(layer.name.toLowerCase());
+      if (isRequired) {
+        lines.push(`  ${pc.red("\u2717")} ${layer.name.padEnd(12)} ${pc.red("missing")}`);
+        lines.push(`    ${pc.dim("\u2192 Fix: aman-agent init")}`);
+        fixes++;
+      } else {
+        lines.push(`  ${pc.yellow("\u26A0")} ${layer.name.padEnd(12)} ${pc.yellow("empty")}`);
+        const cmd = layer.name.toLowerCase() === "workflows" ? "/workflows add <name>" : layer.name.toLowerCase() === "tools" ? "/tools add <name> <type> <desc>" : layer.name.toLowerCase() === "skills" ? "/skills install <name>" : "";
+        if (cmd) lines.push(`    ${pc.dim(`\u2192 Add with ${cmd}`)}`);
+        suggestions++;
+      }
+    }
   }
   lines.push("");
   lines.push(`  ${status.mcpConnected ? pc.green("\u2713") : pc.red("\u2717")} ${"MCP".padEnd(12)} ${status.mcpConnected ? pc.green(`${status.mcpToolCount} tools`) : pc.red("not connected")}`);
+  if (!status.mcpConnected) {
+    lines.push(`    ${pc.dim("\u2192 Fix: ensure npx is available and network is connected")}`);
+    fixes++;
+  } else {
+    healthy++;
+  }
   lines.push(`  ${status.amemConnected ? pc.green("\u2713") : pc.red("\u2717")} ${"Memory".padEnd(12)} ${status.amemConnected ? pc.green("connected") : pc.red("not connected")}`);
+  if (!status.amemConnected) {
+    lines.push(`    ${pc.dim("\u2192 Fix: npx @aman_asmuei/amem")}`);
+    fixes++;
+  } else {
+    healthy++;
+  }
+  const total = healthy + fixes + suggestions;
+  lines.push("");
+  lines.push(`  Overall: ${healthy}/${total} healthy.${fixes > 0 ? ` ${fixes} fix${fixes > 1 ? "es" : ""} needed.` : ""}${suggestions > 0 ? ` ${suggestions} suggestion${suggestions > 1 ? "s" : ""}.` : ""}`);
   return { handled: true, output: lines.join("\n") };
 }
 function handleHelp() {
@@ -904,7 +987,7 @@ function handleHelp() {
       `  ${pc.cyan("/tools")}        View tools [add|remove ...]`,
       `  ${pc.cyan("/skills")}       View skills [install|uninstall ...]`,
       `  ${pc.cyan("/eval")}         View evaluation [milestone ...]`,
-      `  ${pc.cyan("/memory")}       View recent memories [search|clear ...]`,
+      `  ${pc.cyan("/memory")}       View recent memories [search|clear|timeline]`,
       `  ${pc.cyan("/status")}       Ecosystem dashboard`,
       `  ${pc.cyan("/doctor")}       Health check all layers`,
       `  ${pc.cyan("/decisions")}    View decision log [<project>]`,
@@ -1074,6 +1157,41 @@ var isHookCall = false;
 async function onSessionStart(ctx) {
   let greeting = "";
   let contextInjection = "";
+  let firstRun = false;
+  let resumeTopic;
+  const visibleReminders = [];
+  try {
+    isHookCall = true;
+    const recallResult = await ctx.mcpManager.callTool("memory_recall", { query: "*", limit: 1 });
+    if (!recallResult || recallResult.startsWith("Error") || recallResult.includes("No memories found")) {
+      firstRun = true;
+    }
+  } catch {
+    firstRun = true;
+  } finally {
+    isHookCall = false;
+  }
+  if (firstRun) {
+    contextInjection = `<first-session>
+This is your FIRST conversation with this user. Introduce yourself warmly:
+- Share your name and that you're their personal AI companion
+- Mention you'll remember what matters across conversations
+- Ask what they'd like to be called
+- Keep it to 3-4 sentences, natural tone
+</first-session>`;
+    const timeContext2 = getTimeContext();
+    contextInjection = `<session-context>
+${timeContext2}
+</session-context>
+${contextInjection}`;
+    return {
+      greeting: void 0,
+      contextInjection,
+      firstRun,
+      visibleReminders,
+      resumeTopic: void 0
+    };
+  }
   if (ctx.config.memoryRecall) {
     try {
       isHookCall = true;
@@ -1094,6 +1212,10 @@ async function onSessionStart(ctx) {
       if (result && !result.startsWith("Error")) {
         if (greeting) greeting += "\n";
         greeting += result;
+        const topicMatch = result.match(/(?:resume|last|topic)[:\s]*(.+?)(?:\n|$)/i);
+        if (topicMatch) {
+          resumeTopic = topicMatch[1].trim();
+        }
       }
     } catch (err) {
       log.warn("hooks", "identity_summary failed", err);
@@ -1109,6 +1231,10 @@ async function onSessionStart(ctx) {
     const reminderResult = await ctx.mcpManager.callTool("reminder_check", {});
     if (reminderResult && !reminderResult.startsWith("Error") && !reminderResult.includes("No pending")) {
       greeting += "\n\n<pending-reminders>\n" + reminderResult + "\n</pending-reminders>";
+      const lines = reminderResult.split("\n").filter((l) => l.trim().length > 0);
+      for (const line of lines) {
+        visibleReminders.push(line.trim());
+      }
     }
   } catch (err) {
     log.debug("hooks", "reminder_check failed", err);
@@ -1122,7 +1248,10 @@ ${greeting}
   }
   return {
     greeting: greeting || void 0,
-    contextInjection: contextInjection || void 0
+    contextInjection: contextInjection || void 0,
+    firstRun,
+    visibleReminders,
+    resumeTopic
   };
 }
 async function onBeforeToolExec(toolName, toolArgs, ctx) {
@@ -1331,9 +1460,7 @@ ${summaryParts.slice(0, 20).join("\n")}
 }
 
 // src/memory-extractor.ts
-var AUTO_STORE_TYPES = /* @__PURE__ */ new Set(["preference", "fact", "pattern", "topology"]);
-var CONFIRM_TYPES = /* @__PURE__ */ new Set(["decision", "correction"]);
-var VALID_TYPES = /* @__PURE__ */ new Set([...AUTO_STORE_TYPES, ...CONFIRM_TYPES]);
+var VALID_TYPES = /* @__PURE__ */ new Set(["preference", "fact", "pattern", "topology", "decision", "correction"]);
 var MIN_RESPONSE_LENGTH = 50;
 var MIN_TURNS_BETWEEN_EMPTY = 3;
 var EXTRACTION_PROMPT = `Analyze this conversation turn. Extract any information worth remembering long-term.
@@ -1352,8 +1479,8 @@ Type guide:
 - "fact" = objective information about systems, people, projects
 - "pattern" = recurring behavior, coding style, approach
 - "topology" = how systems/components connect to each other
-- "decision" = explicit choice between alternatives (requires confirmation)
-- "correction" = user correcting a prior wrong assumption (requires confirmation)
+- "decision" = explicit choice between alternatives
+- "correction" = user correcting a prior wrong assumption
 
 Rules:
 - Only extract genuinely useful LONG-TERM information
@@ -1382,7 +1509,7 @@ function parseExtractionResult(raw) {
     return [];
   }
 }
-async function extractMemories(userMessage, assistantResponse, client, mcpManager, state, confirmFn) {
+async function extractMemories(userMessage, assistantResponse, client, mcpManager, state) {
   if (!shouldExtract(assistantResponse, state.turnsSinceLastExtraction, state.lastExtractionCount)) {
     state.turnsSinceLastExtraction++;
     return 0;
@@ -1422,10 +1549,6 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
         }
       } catch {
       }
-      if (CONFIRM_TYPES.has(candidate.type)) {
-        const confirmed = await confirmFn(candidate.content);
-        if (!confirmed) continue;
-      }
       try {
         await mcpManager.callTool("memory_store", {
           content: candidate.content,
@@ -1450,24 +1573,111 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
   }
 }
 
+// src/errors.ts
+var ERROR_MAPPINGS = [
+  { pattern: /rate.?limit|429/i, message: "Rate limited. I'll retry automatically." },
+  { pattern: /401|unauthorized/i, message: "API key invalid. Run /reconfig to fix." },
+  { pattern: /403|forbidden/i, message: "API key doesn't have access to this model. Try a different model with --model." },
+  { pattern: /fetch failed|network/i, message: "Network error. Check your internet connection." },
+  { pattern: /ECONNREFUSED/i, message: "Can't reach the API. Are you behind a proxy or firewall?" },
+  { pattern: /context.?length/i, message: "Conversation too long. Use /clear to start fresh or I'll auto-trim." },
+  { pattern: /overloaded/i, message: "API is overloaded. Retrying in a moment..." },
+  { pattern: /ETIMEDOUT/i, message: "Request timed out. Retrying..." }
+];
+function humanizeError(message) {
+  for (const mapping of ERROR_MAPPINGS) {
+    if (mapping.pattern.test(message)) {
+      return mapping.message;
+    }
+  }
+  return message;
+}
+
+// src/hints.ts
+import fs6 from "fs";
+import path6 from "path";
+import os6 from "os";
+var HINTS = [
+  {
+    id: "eval",
+    minTurn: 15,
+    condition: () => true,
+    text: "Tip: See how our relationship has evolved with /eval"
+  },
+  {
+    id: "memory-search",
+    minTurn: 3,
+    condition: (ctx) => ctx.memoryCount >= 10,
+    text: "Tip: Search everything I remember with /memory search <query>"
+  },
+  {
+    id: "workflows",
+    minTurn: 5,
+    condition: (ctx) => !ctx.hasWorkflows,
+    text: "Tip: Teach me multi-step processes with /workflows add"
+  },
+  {
+    id: "rules",
+    minTurn: 8,
+    condition: () => true,
+    text: "Tip: Set guardrails for what I should/shouldn't do with /rules"
+  }
+];
+function getHint(state, ctx) {
+  if (state.hintShownThisSession) return null;
+  for (const hint of HINTS) {
+    if (state.turnCount >= hint.minTurn && !state.shownHints.has(hint.id) && hint.condition(ctx)) {
+      state.shownHints.add(hint.id);
+      state.hintShownThisSession = true;
+      return hint.text;
+    }
+  }
+  return null;
+}
+var HINTS_FILE = path6.join(os6.homedir(), ".aman-agent", "hints-seen.json");
+function loadShownHints() {
+  try {
+    if (fs6.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs6.readFileSync(HINTS_FILE, "utf-8"));
+      return new Set(Array.isArray(data) ? data : []);
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Set();
+}
+function saveShownHints(shown) {
+  try {
+    const dir = path6.dirname(HINTS_FILE);
+    fs6.mkdirSync(dir, { recursive: true });
+    fs6.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+  } catch {
+  }
+}
+
 // src/agent.ts
+marked.use({ renderer: new TerminalRenderer() });
 async function recallForMessage(input, mcpManager) {
   try {
     const result = await mcpManager.callTool("memory_recall", {
       query: input,
-      limit: 5
+      limit: 5,
+      compact: true
     });
-    if (!result || result.startsWith("Error") || result.trim() === "[]") {
-      return "";
+    if (!result || result.startsWith("Error") || result.includes("No memories found")) {
+      return null;
     }
-    return `
+    const tokenEstimate = Math.round(result.split(/\s+/).filter(Boolean).length * 1.3);
+    return {
+      text: `
 
 <relevant-memories>
 ${result}
-</relevant-memories>`;
+</relevant-memories>`,
+      tokenEstimate
+    };
   } catch (err) {
     log.debug("agent", "memory recall failed", err);
-    return "";
+    return null;
   }
 }
 function generateSessionId() {
@@ -1479,13 +1689,35 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager,
   const messages = [];
   const sessionId = generateSessionId();
   const extractorState = { turnsSinceLastExtraction: 0, lastExtractionCount: 0 };
+  const hintState = {
+    turnCount: 0,
+    shownHints: loadShownHints(),
+    hintShownThisSession: false
+  };
   const isRetryable = (err) => err.message.includes("Rate limit") || err.message.includes("rate limit") || err.message.includes("ECONNRESET") || err.message.includes("ETIMEDOUT") || err.message.includes("fetch failed");
+  let responseBuffer = "";
   const onChunkHandler = (chunk) => {
     if (chunk.type === "text" && chunk.text) {
-      process.stdout.write(chunk.text);
+      responseBuffer += chunk.text;
+      if (process.stdout.isTTY) {
+        logUpdate(responseBuffer);
+      } else {
+        process.stdout.write(chunk.text);
+      }
     }
     if (chunk.type === "done") {
-      process.stdout.write("\n");
+      if (process.stdout.isTTY && responseBuffer.trim()) {
+        try {
+          const rendered = marked(responseBuffer.trim());
+          logUpdate(rendered);
+          logUpdate.done();
+        } catch {
+          logUpdate.done();
+        }
+      } else {
+        process.stdout.write("\n");
+      }
+      responseBuffer = "";
     }
   };
   const rl = readline.createInterface({
@@ -1521,10 +1753,25 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
     const hookCtx = { mcpManager, config: hooksConfig };
     try {
       const session = await onSessionStart(hookCtx);
-      if (session.greeting) console.log(pc3.dim(session.greeting));
+      if (!session.firstRun) {
+        if (session.resumeTopic) {
+          console.log(pc3.dim(`  Welcome back. Last time we talked about ${session.resumeTopic}`));
+        } else {
+          console.log(pc3.dim("  Welcome back."));
+        }
+      }
+      if (session.visibleReminders && session.visibleReminders.length > 0) {
+        for (const reminder of session.visibleReminders) {
+          console.log(pc3.yellow(`  Reminder: ${reminder}`));
+        }
+      }
       if (session.contextInjection) {
         messages.push({ role: "user", content: session.contextInjection });
-        messages.push({ role: "assistant", content: "I have context from our previous sessions. How can I help?" });
+        if (session.firstRun) {
+          messages.push({ role: "assistant", content: "acknowledged" });
+        } else {
+          messages.push({ role: "assistant", content: "I have context from our previous sessions. How can I help?" });
+        }
       }
     } catch (err) {
       log.warn("agent", "session start hook failed", err);
@@ -1550,9 +1797,9 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path6.join(os6.homedir(), ".aman-agent", "exports");
-          fs6.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path6.join(exportDir, `${sessionId}.md`);
+          const exportDir = path7.join(os7.homedir(), ".aman-agent", "exports");
+          fs7.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path7.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -1566,7 +1813,7 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs6.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          fs7.writeFileSync(exportPath, lines.join("\n"), "utf-8");
           console.log(pc3.green(`Exported to ${exportPath}`));
         } catch {
           console.log(pc3.red("Failed to export conversation."));
@@ -1615,14 +1862,19 @@ ${wfMatch.steps}
     await trimConversation(messages, client);
     messages.push({ role: "user", content: input });
     let augmentedSystemPrompt = activeSystemPrompt;
+    let memoryTokens = 0;
     if (mcpManager) {
-      const memories = await recallForMessage(input, mcpManager);
-      if (memories) {
-        augmentedSystemPrompt = activeSystemPrompt + memories;
+      const recall = await recallForMessage(input, mcpManager);
+      if (recall) {
+        augmentedSystemPrompt = activeSystemPrompt + recall.text;
+        memoryTokens = recall.tokenEstimate;
       }
     }
-    process.stdout.write(pc3.cyan(`
-${aiName} > `));
+    const divider = "\u2500".repeat(Math.min(process.stdout.columns || 60, 60) - aiName.length - 2);
+    process.stdout.write(`
+ ${pc3.cyan(pc3.bold(aiName))} ${pc3.dim(divider)}
+
+`);
     try {
       let response = await withRetry(
         () => client.chat(augmentedSystemPrompt, messages, onChunkHandler, tools),
@@ -1649,6 +1901,15 @@ ${aiName} > `));
             process.stdout.write(pc3.dim(`  [using ${toolUse.name}...]
 `));
             const result = await mcpManager.callTool(toolUse.name, toolUse.input);
+            const skipLogging = ["memory_log", "memory_recall", "memory_context", "memory_detail", "reminder_check"].includes(toolUse.name);
+            if (!skipLogging) {
+              mcpManager.callTool("memory_log", {
+                session_id: sessionId,
+                role: "system",
+                content: `[tool:${toolUse.name}] input=${JSON.stringify(toolUse.input).slice(0, 500)} result=${result.slice(0, 500)}`
+              }).catch(() => {
+              });
+            }
             return {
               type: "tool_result",
               tool_use_id: toolUse.id,
@@ -1666,24 +1927,21 @@ ${aiName} > `));
         );
         messages.push(response.message);
       }
+      const footerParts = [];
+      if (memoryTokens > 0) footerParts.push(`memories: ~${memoryTokens} tokens`);
+      const footer = footerParts.length > 0 ? ` ${footerParts.join(" | ")}` : "";
+      const footerDivider = "\u2500".repeat(Math.min(process.stdout.columns || 60, 60) - footer.length - 1);
+      process.stdout.write(pc3.dim(` ${footerDivider}${footer}
+`));
       if (mcpManager && hooksConfig?.extractMemories) {
         const assistantText = typeof response.message.content === "string" ? response.message.content : response.message.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("");
         if (assistantText) {
-          const confirmFn = async (content) => {
-            return new Promise((resolve) => {
-              rl.question(
-                pc3.dim(`  Remember: "${content}"? (y/N) `),
-                (answer) => resolve(answer.toLowerCase() === "y")
-              );
-            });
-          };
           const count = await extractMemories(
             input,
             assistantText,
             client,
             mcpManager,
-            extractorState,
-            confirmFn
+            extractorState
           );
           if (count > 0) {
             process.stdout.write(pc3.dim(`  [${count} memory${count > 1 ? "ies" : ""} stored]
@@ -1693,11 +1951,22 @@ ${aiName} > `));
       } else {
         extractorState.turnsSinceLastExtraction++;
       }
+      if (hooksConfig?.featureHints) {
+        hintState.turnCount++;
+        const hasWorkflows = fs7.existsSync(path7.join(os7.homedir(), ".aflow", "flow.md"));
+        const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
+        const hint = getHint(hintState, { hasWorkflows, memoryCount });
+        if (hint) {
+          process.stdout.write(pc3.dim(`  ${hint}
+`));
+          saveShownHints(hintState.shownHints);
+        }
+      }
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error occurred";
+      const rawMessage = error instanceof Error ? error.message : "Unknown error occurred";
+      const friendly = humanizeError(rawMessage);
       console.error(pc3.red(`
-Error: ${message}`));
-      messages.pop();
+  ${friendly}`));
     }
   }
 }
@@ -1718,106 +1987,281 @@ async function saveConversationToMemory(mcpManager, messages, sessionId) {
 }
 
 // src/index.ts
-import fs7 from "fs";
-import path7 from "path";
-import os7 from "os";
+import fs8 from "fs";
+import path8 from "path";
+import os8 from "os";
+
+// src/presets.ts
+var PRESETS = {
+  coding: {
+    identity: {
+      personality: "Direct, technical, concise. Shows code over explanation.",
+      style: "Use short answers. Lead with the solution, explain after."
+    },
+    rules: [
+      { category: "response", rule: "Always show code examples, not just descriptions" },
+      { category: "safety", rule: "Never execute destructive commands without confirmation" },
+      { category: "quality", rule: "Follow project conventions over personal preference" }
+    ],
+    workflows: [
+      { name: "debug", description: "Systematic debugging process", steps: ["Reproduce the issue", "Identify root cause", "Propose fix", "Verify fix"] }
+    ]
+  },
+  creative: {
+    identity: {
+      personality: "Warm, imaginative, encouraging. Explores multiple angles.",
+      style: "Use metaphors and vivid language. Ask 'what if' questions."
+    },
+    rules: [
+      { category: "response", rule: "Always offer 2-3 alternative approaches" },
+      { category: "tone", rule: "Encourage experimentation, never dismiss ideas" }
+    ],
+    workflows: [
+      { name: "brainstorm", description: "Creative brainstorming process", steps: ["Explore the problem space", "Generate 5+ ideas", "Evaluate trade-offs", "Refine top 2"] }
+    ]
+  },
+  assistant: {
+    identity: {
+      personality: "Organized, proactive, action-oriented.",
+      style: "Use bullet points and checklists. Summarize key takeaways."
+    },
+    rules: [
+      { category: "response", rule: "End responses with clear next steps when applicable" },
+      { category: "memory", rule: "Always track deadlines and commitments mentioned" }
+    ],
+    workflows: [
+      { name: "plan", description: "Task planning process", steps: ["Clarify the goal", "Break into tasks", "Prioritize", "Set deadlines"] }
+    ]
+  },
+  learning: {
+    identity: {
+      personality: "Patient, curious, Socratic. Builds understanding layer by layer.",
+      style: "Use analogies. Check understanding before moving on."
+    },
+    rules: [
+      { category: "response", rule: "Explain concepts before showing solutions" },
+      { category: "teaching", rule: "Ask a follow-up question to reinforce learning" }
+    ],
+    workflows: []
+  },
+  minimal: {
+    identity: {
+      personality: "Helpful and adaptive. Matches the user's tone and needs.",
+      style: "Clear and concise. Prioritizes usefulness over verbosity."
+    },
+    rules: [],
+    workflows: []
+  }
+};
+function applyPreset(name, companionName) {
+  const preset = PRESETS[name];
+  const coreMd = [
+    `# ${companionName}`,
+    "",
+    "## Personality",
+    preset.identity.personality,
+    "",
+    "## Style",
+    preset.identity.style,
+    "",
+    "## Session",
+    "_New companion \u2014 no prior sessions._"
+  ].join("\n");
+  let rulesMd = null;
+  if (preset.rules.length > 0) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const r of preset.rules) {
+      if (!grouped.has(r.category)) grouped.set(r.category, []);
+      grouped.get(r.category).push(r.rule);
+    }
+    const sections = [...grouped.entries()].map(([cat, rules]) => `## ${cat}
+${rules.map((r) => `- ${r}`).join("\n")}`).join("\n\n");
+    rulesMd = `# Guardrails
+
+${sections}`;
+  }
+  let flowMd = null;
+  if (preset.workflows.length > 0) {
+    const wfSections = preset.workflows.map((wf) => {
+      const steps = wf.steps.map((s, i) => `${i + 1}. ${s}`).join("\n");
+      return `## ${wf.name}
+${wf.description}
+
+${steps}`;
+    }).join("\n\n");
+    flowMd = `# Workflows
+
+${wfSections}`;
+  }
+  return { coreMd, rulesMd, flowMd };
+}
+
+// src/index.ts
+async function autoDetectConfig() {
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  if (anthropicKey) {
+    return { provider: "anthropic", apiKey: anthropicKey, model: "claude-sonnet-4-6" };
+  }
+  const openaiKey = process.env.OPENAI_API_KEY;
+  if (openaiKey) {
+    return { provider: "openai", apiKey: openaiKey, model: "gpt-4o" };
+  }
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e3);
+    const res = await fetch("http://localhost:11434/", { signal: controller.signal });
+    clearTimeout(timeout);
+    if (res.ok) {
+      return { provider: "ollama", apiKey: "ollama", model: "llama3.2" };
+    }
+  } catch {
+  }
+  return null;
+}
+function bootstrapEcosystem() {
+  const home2 = os8.homedir();
+  const corePath = path8.join(home2, ".acore", "core.md");
+  if (fs8.existsSync(corePath)) return false;
+  fs8.mkdirSync(path8.join(home2, ".acore"), { recursive: true });
+  fs8.writeFileSync(corePath, [
+    "# Aman",
+    "",
+    "## Personality",
+    "Helpful, adaptive, and thoughtful. Matches the user's tone and needs.",
+    "",
+    "## Style",
+    "Clear and concise. Prioritizes usefulness over verbosity.",
+    "",
+    "## Session",
+    "_New companion \u2014 no prior sessions._"
+  ].join("\n"), "utf-8");
+  const rulesDir = path8.join(home2, ".arules");
+  const rulesPath = path8.join(rulesDir, "rules.md");
+  if (!fs8.existsSync(rulesPath)) {
+    fs8.mkdirSync(rulesDir, { recursive: true });
+    fs8.writeFileSync(rulesPath, [
+      "# Guardrails",
+      "",
+      "## safety",
+      "- Never execute destructive commands without explicit confirmation",
+      "- Never expose API keys, passwords, or secrets in responses",
+      "",
+      "## behavior",
+      `- Be honest when uncertain \u2014 say "I'm not sure" rather than guessing`,
+      "- Respect the user's preferences stored in memory"
+    ].join("\n"), "utf-8");
+  }
+  return true;
+}
 var program = new Command();
 program.name("aman-agent").description("Your AI companion, running locally").version("0.1.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).action(async (options) => {
-  p2.intro(pc4.bold("aman agent") + pc4.dim(" \u2014 starting your AI companion"));
+  p2.intro(pc4.bold("aman agent") + pc4.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
-    p2.log.info("First-time setup \u2014 configure your LLM connection.");
-    const provider = await p2.select({
-      message: "LLM provider",
-      options: [
-        {
-          value: "anthropic",
-          label: "Claude (Anthropic)",
-          hint: "recommended"
-        },
-        { value: "openai", label: "GPT (OpenAI)" },
-        { value: "ollama", label: "Ollama (local)", hint: "free, runs offline" }
-      ],
-      initialValue: "anthropic"
-    });
-    if (p2.isCancel(provider)) process.exit(0);
-    let apiKey = "";
-    let defaultModel = "";
-    if (provider === "ollama") {
-      apiKey = "ollama";
-      const modelInput = await p2.text({
-        message: "Ollama model name",
-        placeholder: "llama3.2",
-        defaultValue: "llama3.2"
-      });
-      if (p2.isCancel(modelInput)) process.exit(0);
-      defaultModel = modelInput || "llama3.2";
-    } else if (provider === "anthropic") {
-      p2.log.info("Get your API key from: https://console.anthropic.com/settings/keys");
-      p2.log.info(pc4.dim("Note: API access is separate from Claude Pro subscription. You need API credits."));
-      apiKey = await p2.text({
-        message: "API key (starts with sk-ant-)",
-        validate: (v) => v.length === 0 ? "API key is required" : void 0
-      });
-      if (p2.isCancel(apiKey)) process.exit(0);
-      const modelChoice = await p2.select({
-        message: "Claude model",
-        options: [
-          { value: "claude-sonnet-4-5-20250514", label: "Claude Sonnet 4.5", hint: "fast, recommended" },
-          { value: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "most capable" },
-          { value: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5", hint: "fastest, cheapest" },
-          { value: "custom", label: "Custom model ID" }
-        ],
-        initialValue: "claude-sonnet-4-5-20250514"
-      });
-      if (p2.isCancel(modelChoice)) process.exit(0);
-      if (modelChoice === "custom") {
-        const customModel = await p2.text({
-          message: "Model ID",
-          placeholder: "claude-sonnet-4-5-20250514",
-          validate: (v) => v.length === 0 ? "Model ID is required" : void 0
-        });
-        if (p2.isCancel(customModel)) process.exit(0);
-        defaultModel = customModel;
-      } else {
-        defaultModel = modelChoice;
-      }
+    const detected = await autoDetectConfig();
+    if (detected) {
+      config = detected;
+      const providerLabel = detected.provider === "anthropic" ? "Anthropic API key" : detected.provider === "openai" ? "OpenAI API key" : "Ollama";
+      const modelLabel = detected.provider === "anthropic" ? "Claude Sonnet 4.6" : detected.provider === "openai" ? "GPT-4o" : "Llama 3.2";
+      p2.log.success(`Auto-detected ${providerLabel}. Using ${modelLabel}.`);
     } else {
-      apiKey = await p2.text({
-        message: "API key",
-        validate: (v) => v.length === 0 ? "API key is required" : void 0
-      });
-      if (p2.isCancel(apiKey)) process.exit(0);
-      const modelChoice = await p2.select({
-        message: "OpenAI model",
+      p2.log.info("First-time setup \u2014 configure your LLM connection.");
+      const provider = await p2.select({
+        message: "LLM provider",
         options: [
-          { value: "gpt-4o", label: "GPT-4o", hint: "recommended" },
-          { value: "gpt-4o-mini", label: "GPT-4o Mini", hint: "faster, cheaper" },
-          { value: "o3", label: "o3", hint: "reasoning model" },
-          { value: "custom", label: "Custom model ID" }
+          {
+            value: "anthropic",
+            label: "Claude (Anthropic)",
+            hint: "recommended"
+          },
+          { value: "openai", label: "GPT (OpenAI)" },
+          { value: "ollama", label: "Ollama (local)", hint: "free, runs offline" }
         ],
-        initialValue: "gpt-4o"
+        initialValue: "anthropic"
       });
-      if (p2.isCancel(modelChoice)) process.exit(0);
-      if (modelChoice === "custom") {
-        const customModel = await p2.text({
-          message: "Model ID",
-          placeholder: "gpt-4o",
-          validate: (v) => v.length === 0 ? "Model ID is required" : void 0
+      if (p2.isCancel(provider)) process.exit(0);
+      let apiKey = "";
+      let defaultModel = "";
+      if (provider === "ollama") {
+        apiKey = "ollama";
+        const modelInput = await p2.text({
+          message: "Ollama model name",
+          placeholder: "llama3.2",
+          defaultValue: "llama3.2"
+        });
+        if (p2.isCancel(modelInput)) process.exit(0);
+        defaultModel = modelInput || "llama3.2";
+      } else if (provider === "anthropic") {
+        p2.log.info("Get your API key from: https://console.anthropic.com/settings/keys");
+        p2.log.info(pc4.dim("Note: API access is separate from Claude Pro subscription. You need API credits."));
+        apiKey = await p2.text({
+          message: "API key (starts with sk-ant-)",
+          validate: (v) => v.length === 0 ? "API key is required" : void 0
         });
-        if (p2.isCancel(customModel)) process.exit(0);
-        defaultModel = customModel;
+        if (p2.isCancel(apiKey)) process.exit(0);
+        const modelChoice = await p2.select({
+          message: "Claude model",
+          options: [
+            { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "fast, recommended" },
+            { value: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "most capable" },
+            { value: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5", hint: "fastest, cheapest" },
+            { value: "custom", label: "Custom model ID" }
+          ],
+          initialValue: "claude-sonnet-4-6"
+        });
+        if (p2.isCancel(modelChoice)) process.exit(0);
+        if (modelChoice === "custom") {
+          const customModel = await p2.text({
+            message: "Model ID",
+            placeholder: "claude-sonnet-4-6",
+            validate: (v) => v.length === 0 ? "Model ID is required" : void 0
+          });
+          if (p2.isCancel(customModel)) process.exit(0);
+          defaultModel = customModel;
+        } else {
+          defaultModel = modelChoice;
+        }
       } else {
-        defaultModel = modelChoice;
+        apiKey = await p2.text({
+          message: "API key",
+          validate: (v) => v.length === 0 ? "API key is required" : void 0
+        });
+        if (p2.isCancel(apiKey)) process.exit(0);
+        const modelChoice = await p2.select({
+          message: "OpenAI model",
+          options: [
+            { value: "gpt-4o", label: "GPT-4o", hint: "recommended" },
+            { value: "gpt-4o-mini", label: "GPT-4o Mini", hint: "faster, cheaper" },
+            { value: "o3", label: "o3", hint: "reasoning model" },
+            { value: "custom", label: "Custom model ID" }
+          ],
+          initialValue: "gpt-4o"
+        });
+        if (p2.isCancel(modelChoice)) process.exit(0);
+        if (modelChoice === "custom") {
+          const customModel = await p2.text({
+            message: "Model ID",
+            placeholder: "gpt-4o",
+            validate: (v) => v.length === 0 ? "Model ID is required" : void 0
+          });
+          if (p2.isCancel(customModel)) process.exit(0);
+          defaultModel = customModel;
+        } else {
+          defaultModel = modelChoice;
+        }
       }
+      config = { provider, apiKey, model: defaultModel };
+      saveConfig(config);
+      p2.log.success("Config saved to ~/.aman-agent/config.json");
     }
-    config = { provider, apiKey, model: defaultModel };
-    saveConfig(config);
-    p2.log.success("Config saved to ~/.aman-agent/config.json");
   }
   const model = options.model || config.model;
+  const s = p2.spinner();
+  s.start("Loading ecosystem");
+  bootstrapEcosystem();
   const budget = options.budget || void 0;
   const { prompt: systemPrompt, layers, truncated, totalTokens } = assembleSystemPrompt(budget);
+  s.stop("Ecosystem loaded");
   if (layers.length === 0) {
     p2.log.warning(
       "No ecosystem configured. Run " + pc4.bold("npx @aman_asmuei/aman") + " first."
@@ -1831,37 +2275,44 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
       p2.log.warning(`Truncated: ${truncated.join(", ")} ${pc4.dim("(over budget)")}`);
     }
   }
-  p2.log.info(`Model: ${pc4.dim(model)}`);
-  const corePath = path7.join(os7.homedir(), ".acore", "core.md");
+  const corePath = path8.join(os8.homedir(), ".acore", "core.md");
   let aiName = "Assistant";
-  if (fs7.existsSync(corePath)) {
-    const content = fs7.readFileSync(corePath, "utf-8");
+  if (fs8.existsSync(corePath)) {
+    const content = fs8.readFileSync(corePath, "utf-8");
     const match = content.match(/^# (.+)$/m);
     if (match) aiName = match[1];
   }
-  p2.log.success(`${pc4.bold(aiName)} is ready.`);
   const mcpManager = new McpManager();
-  p2.log.step("Connecting to MCP servers...");
+  const mcpSpinner = p2.spinner();
+  mcpSpinner.start("Connecting to MCP servers");
   await mcpManager.connect("aman", "npx", ["-y", "@aman_asmuei/aman-mcp"]);
   await mcpManager.connect("amem", "npx", ["-y", "@aman_asmuei/amem"]);
   const mcpTools = mcpManager.getTools();
+  mcpSpinner.stop("MCP connected");
   if (mcpTools.length > 0) {
     p2.log.success(`${mcpTools.length} MCP tools available`);
     if (mcpTools.some((t) => t.name === "memory_consolidate")) {
+      const memSpinner = p2.spinner();
+      memSpinner.start("Consolidating memory");
       try {
         const consolidateResult = await mcpManager.callTool("memory_consolidate", { dry_run: false });
         if (consolidateResult && !consolidateResult.startsWith("Error")) {
           try {
             const report = JSON.parse(consolidateResult);
+            memSpinner.stop("Memory consolidated");
             if (report.merged > 0 || report.pruned > 0 || report.promoted > 0) {
               p2.log.info(
                 `Memory health: ${report.healthScore ?? "?"}% ` + pc4.dim(`(merged ${report.merged}, pruned ${report.pruned}, promoted ${report.promoted})`)
               );
             }
           } catch {
+            memSpinner.stop("Memory consolidated");
           }
+        } else {
+          memSpinner.stop("Memory consolidated");
         }
       } catch {
+        memSpinner.stop("Memory consolidation skipped");
       }
     }
   } else {
@@ -1882,6 +2333,7 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   } else {
     client = createOpenAIClient(config.apiKey, model);
   }
+  p2.log.success(`${pc4.bold(aiName)} is ready. Model: ${pc4.dim(model)}`);
   await runAgent(
     client,
     systemPrompt,
@@ -1893,5 +2345,44 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   );
   await mcpManager.disconnect();
 });
+program.command("init").description("Set up your AI companion with a guided wizard").action(async () => {
+  p2.intro(pc4.bold("aman agent init") + pc4.dim(" \u2014 set up your companion"));
+  const name = await p2.text({
+    message: "What should your companion be called?",
+    placeholder: "Aman",
+    defaultValue: "Aman"
+  });
+  if (p2.isCancel(name)) process.exit(0);
+  const preset = await p2.select({
+    message: "What kind of companion do you need?",
+    options: [
+      { value: "coding", label: "Coding Partner", hint: "direct, technical, concise" },
+      { value: "creative", label: "Creative Collaborator", hint: "warm, imaginative" },
+      { value: "assistant", label: "Personal Assistant", hint: "organized, action-oriented" },
+      { value: "learning", label: "Learning Buddy", hint: "patient, Socratic" },
+      { value: "minimal", label: "Minimal", hint: "just chat, I'll customize later" }
+    ],
+    initialValue: "coding"
+  });
+  if (p2.isCancel(preset)) process.exit(0);
+  const result = applyPreset(preset, name || "Aman");
+  const home2 = os8.homedir();
+  fs8.mkdirSync(path8.join(home2, ".acore"), { recursive: true });
+  fs8.writeFileSync(path8.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
+  p2.log.success(`Identity created \u2014 ${PRESETS[preset].identity.personality.split(".")[0].toLowerCase()}`);
+  if (result.rulesMd) {
+    fs8.mkdirSync(path8.join(home2, ".arules"), { recursive: true });
+    fs8.writeFileSync(path8.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
+    const ruleCount = (result.rulesMd.match(/^- /gm) || []).length;
+    p2.log.success(`${ruleCount} rules set`);
+  }
+  if (result.flowMd) {
+    fs8.mkdirSync(path8.join(home2, ".aflow"), { recursive: true });
+    fs8.writeFileSync(path8.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
+    const wfCount = (result.flowMd.match(/^## /gm) || []).length;
+    p2.log.success(`${wfCount} workflow${wfCount > 1 ? "s" : ""} added`);
+  }
+  p2.outro(`Your companion is ready. Run: ${pc4.bold("aman-agent")}`);
+});
 program.parse();
 //# sourceMappingURL=index.js.map