@aman_asmuei/aman-agent 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
 import { Command } from "commander";
 import * as p2 from "@clack/prompts";
-import pc5 from "picocolors";
+import pc4 from "picocolors";
 
 // src/config.ts
 import fs from "fs";
@@ -172,76 +172,83 @@ function createAnthropicClient(apiKey, model) {
       const anthropicMessages = toAnthropicMessages(messages);
       const hasTools = tools && tools.length > 0;
       try {
+        let fullText = "";
+        const toolUseBlocks = [];
+        let currentBlockType = null;
+        let currentBlockIndex = -1;
+        const createParams = {
+          model,
+          max_tokens: 8192,
+          system: systemPrompt,
+          messages: anthropicMessages,
+          stream: true
+        };
         if (hasTools) {
-          const response = await client.messages.create({
-            model,
-            max_tokens: 8192,
-            system: systemPrompt,
-            messages: anthropicMessages,
-            tools: tools.map((t) => ({
-              name: t.name,
-              description: t.description,
-              input_schema: t.input_schema
-            }))
-          });
-          const toolUses = response.content.filter(
-            (block) => block.type === "tool_use"
-          ).map((block) => ({
-            id: block.id,
-            name: block.name,
-            input: block.input
+          createParams.tools = tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.input_schema
           }));
-          const textContent = response.content.filter(
-            (block) => block.type === "text"
-          ).map((block) => block.text).join("");
-          if (textContent && toolUses.length === 0) {
-            onChunk({ type: "text", text: textContent });
-            onChunk({ type: "done" });
-          } else if (textContent) {
-            onChunk({ type: "text", text: textContent });
-          }
-          const contentBlocks = response.content.map(
-            (block) => {
-              if (block.type === "text") {
-                return { type: "text", text: block.text };
-              }
-              return {
-                type: "tool_use",
-                id: block.id,
-                name: block.name,
-                input: block.input
-              };
+        }
+        const stream = await client.messages.create(
+          createParams
+        );
+        for await (const event of stream) {
+          if (event.type === "content_block_start") {
+            currentBlockIndex = event.index;
+            if (event.content_block.type === "text") {
+              currentBlockType = "text";
+            } else if (event.content_block.type === "tool_use") {
+              currentBlockType = "tool_use";
+              toolUseBlocks.push({
+                id: event.content_block.id,
+                name: event.content_block.name,
+                inputJson: ""
+              });
             }
-          );
-          return {
-            message: {
-              role: "assistant",
-              content: toolUses.length > 0 ? contentBlocks : textContent
-            },
-            toolUses
-          };
-        } else {
-          let fullText = "";
-          const stream = await client.messages.create({
-            model,
-            max_tokens: 8192,
-            system: systemPrompt,
-            messages: anthropicMessages,
-            stream: true
-          });
-          for await (const event of stream) {
-            if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          } else if (event.type === "content_block_delta") {
+            if (currentBlockType === "text" && event.delta.type === "text_delta") {
               const text2 = event.delta.text;
               fullText += text2;
               onChunk({ type: "text", text: text2 });
+            } else if (currentBlockType === "tool_use" && event.delta.type === "input_json_delta") {
+              const lastTool = toolUseBlocks[toolUseBlocks.length - 1];
+              if (lastTool) {
+                lastTool.inputJson += event.delta.partial_json;
+              }
             }
+          } else if (event.type === "content_block_stop") {
+            currentBlockType = null;
+          }
+        }
+        const toolUses = toolUseBlocks.map((block) => ({
+          id: block.id,
+          name: block.name,
+          input: block.inputJson ? JSON.parse(block.inputJson) : {}
+        }));
+        onChunk({ type: "done" });
+        if (toolUses.length > 0) {
+          const contentBlocks = [];
+          if (fullText) {
+            contentBlocks.push({ type: "text", text: fullText });
+          }
+          for (const tu of toolUses) {
+            contentBlocks.push({
+              type: "tool_use",
+              id: tu.id,
+              name: tu.name,
+              input: tu.input
+            });
           }
-          onChunk({ type: "done" });
           return {
-            message: { role: "assistant", content: fullText },
-            toolUses: []
+            message: { role: "assistant", content: contentBlocks },
+            toolUses
           };
         }
+        return {
+          message: { role: "assistant", content: fullText },
+          toolUses: []
+        };
       } catch (error) {
         if (error instanceof Anthropic.AuthenticationError) {
           throw new Error(
@@ -316,74 +323,79 @@ function createOpenAIClient(apiKey, model) {
       const openaiMessages = toOpenAIMessages(systemPrompt, messages);
       const hasTools = tools && tools.length > 0;
       try {
+        let fullText = "";
+        const toolCallAccumulators = /* @__PURE__ */ new Map();
+        const createParams = {
+          model,
+          max_tokens: 8192,
+          messages: openaiMessages,
+          stream: true
+        };
         if (hasTools) {
-          const response = await client.chat.completions.create({
-            model,
-            max_tokens: 8192,
-            messages: openaiMessages,
-            tools: tools.map((t) => ({
-              type: "function",
-              function: {
-                name: t.name,
-                description: t.description,
-                parameters: t.input_schema
-              }
-            }))
-          });
-          const choice = response.choices[0];
-          const textContent = choice?.message?.content || "";
-          const toolCalls = choice?.message?.tool_calls || [];
-          const toolUses = toolCalls.map((tc) => ({
-            id: tc.id,
-            name: tc.function.name,
-            input: JSON.parse(tc.function.arguments || "{}")
+          createParams.tools = tools.map((t) => ({
+            type: "function",
+            function: {
+              name: t.name,
+              description: t.description,
+              parameters: t.input_schema
+            }
           }));
-          if (textContent && toolUses.length === 0) {
-            onChunk({ type: "text", text: textContent });
-            onChunk({ type: "done" });
-          } else if (textContent) {
-            onChunk({ type: "text", text: textContent });
-          }
-          if (toolUses.length > 0) {
-            const contentBlocks = [
-              ...textContent ? [{ type: "text", text: textContent }] : [],
-              ...toolUses.map((tu) => ({
-                type: "tool_use",
-                id: tu.id,
-                name: tu.name,
-                input: tu.input
-              }))
-            ];
-            return {
-              message: { role: "assistant", content: contentBlocks },
-              toolUses
-            };
+        }
+        const stream = await client.chat.completions.create(
+          createParams
+        );
+        for await (const chunk of stream) {
+          const delta = chunk.choices[0]?.delta;
+          if (!delta) continue;
+          if (delta.content) {
+            fullText += delta.content;
+            onChunk({ type: "text", text: delta.content });
           }
-          return {
-            message: { role: "assistant", content: textContent },
-            toolUses: []
-          };
-        } else {
-          let fullText = "";
-          const stream = await client.chat.completions.create({
-            model,
-            max_tokens: 8192,
-            messages: openaiMessages,
-            stream: true
-          });
-          for await (const chunk of stream) {
-            const text2 = chunk.choices[0]?.delta?.content || "";
-            if (text2) {
-              fullText += text2;
-              onChunk({ type: "text", text: text2 });
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index;
+              let acc = toolCallAccumulators.get(idx);
+              if (!acc) {
+                acc = { id: "", name: "", arguments: "" };
+                toolCallAccumulators.set(idx, acc);
+              }
+              if (tc.id) {
+                acc.id = tc.id;
+              }
+              if (tc.function?.name) {
+                acc.name = tc.function.name;
+              }
+              if (tc.function?.arguments) {
+                acc.arguments += tc.function.arguments;
+              }
             }
           }
-          onChunk({ type: "done" });
+        }
+        const toolUses = Array.from(toolCallAccumulators.entries()).sort(([a], [b]) => a - b).map(([, acc]) => ({
+          id: acc.id,
+          name: acc.name,
+          input: JSON.parse(acc.arguments || "{}")
+        }));
+        onChunk({ type: "done" });
+        if (toolUses.length > 0) {
+          const contentBlocks = [
+            ...fullText ? [{ type: "text", text: fullText }] : [],
+            ...toolUses.map((tu) => ({
+              type: "tool_use",
+              id: tu.id,
+              name: tu.name,
+              input: tu.input
+            }))
+          ];
           return {
-            message: { role: "assistant", content: fullText },
-            toolUses: []
+            message: { role: "assistant", content: contentBlocks },
+            toolUses
           };
         }
+        return {
+          message: { role: "assistant", content: fullText },
+          toolUses: []
+        };
       } catch (error) {
         if (error instanceof OpenAI.AuthenticationError) {
           throw new Error(
@@ -821,7 +833,7 @@ function handleHelp() {
       `  ${pc.cyan("/memory")}       View recent memories [search|clear ...]`,
       `  ${pc.cyan("/status")}       Ecosystem dashboard`,
       `  ${pc.cyan("/doctor")}       Health check all layers`,
-      `  ${pc.cyan("/remind")}       Set a reminder`,
+      `  ${pc.cyan("/save")}         Save conversation to memory`,
       `  ${pc.cyan("/model")}        Show current LLM model`,
       `  ${pc.cyan("/update")}       Check for updates`,
       `  ${pc.cyan("/reconfig")}     Reset LLM config`,
@@ -830,17 +842,8 @@ function handleHelp() {
     ].join("\n")
   };
 }
-function handleRemind(input) {
-  const parts = input.trim().split(/\s+/);
-  if (parts.length < 3) {
-    return {
-      handled: true,
-      output: "Usage: /remind <time> <message>\nExamples: /remind 30m Review PR, /remind 2h Deploy, /remind tomorrow Check metrics"
-    };
-  }
-  const timeStr = parts[1];
-  const message = parts.slice(2).join(" ");
-  return { handled: true, remind: { timeStr, message } };
+function handleSave() {
+  return { handled: true, saveConversation: true };
 }
 function handleReconfig() {
   const configPath = path4.join(os4.homedir(), ".aman-agent", "config.json");
@@ -921,8 +924,8 @@ async function handleCommand(input, ctx) {
       return handleStatusCommand(ctx);
     case "doctor":
       return handleDoctorCommand(ctx);
-    case "remind":
-      return handleRemind(trimmed);
+    case "save":
+      return handleSave();
     case "update-config":
     case "reconfig":
       return handleReconfig();
@@ -934,46 +937,8 @@ async function handleCommand(input, ctx) {
   }
 }
 
-// src/reminders.ts
-import pc2 from "picocolors";
-var activeReminders = [];
-function parseTime(timeStr) {
-  const match = timeStr.match(/^(\d+)(m|h)$/);
-  if (match) {
-    const value = parseInt(match[1]);
-    const unit = match[2];
-    return unit === "m" ? value * 60 * 1e3 : value * 60 * 60 * 1e3;
-  }
-  if (timeStr === "tomorrow") return 24 * 60 * 60 * 1e3;
-  return null;
-}
-function setReminder(timeStr, message) {
-  const ms = parseTime(timeStr);
-  if (!ms) return null;
-  const reminder = {
-    message,
-    dueAt: Date.now() + ms
-  };
-  reminder.timer = setTimeout(() => {
-    console.log(`
-${pc2.yellow("\u23F0")} ${pc2.bold("Reminder:")} ${message}`);
-    const idx = activeReminders.indexOf(reminder);
-    if (idx >= 0) activeReminders.splice(idx, 1);
-  }, ms);
-  activeReminders.push(reminder);
-  const mins = Math.round(ms / 6e4);
-  if (mins < 60) return `${mins} minutes`;
-  const hours = Math.round(mins / 60);
-  return `${hours} hour${hours > 1 ? "s" : ""}`;
-}
-function clearReminders() {
-  for (const r of activeReminders) {
-    if (r.timer) clearTimeout(r.timer);
-  }
-  activeReminders.length = 0;
-}
-
 // src/hooks.ts
+import pc2 from "picocolors";
 import * as p from "@clack/prompts";
 var isHookCall = false;
 async function onSessionStart(ctx) {
@@ -1076,33 +1041,24 @@ async function onWorkflowMatch(userInput, ctx) {
     isHookCall = false;
   }
 }
-async function onSessionEnd(ctx, messages) {
+async function onSessionEnd(ctx, messages, sessionId) {
   try {
-    if (ctx.config.evalPrompt) {
-      const rating = await p.select({
-        message: "Quick rating for this session?",
-        options: [
-          { value: "great", label: "Great" },
-          { value: "good", label: "Good" },
-          { value: "okay", label: "Okay" },
-          { value: "skip", label: "Skip" }
-        ],
-        initialValue: "skip"
-      });
-      if (!p.isCancel(rating) && rating !== "skip") {
+    if (ctx.config.autoSessionSave && messages.length > 2) {
+      console.log(pc2.dim("\n  Saving conversation to memory..."));
+      const textMessages = messages.filter((m) => typeof m.content === "string").slice(-50);
+      for (const msg of textMessages) {
         try {
           isHookCall = true;
-          await ctx.mcpManager.callTool("eval_log", {
-            rating,
-            highlights: "Quick session rating",
-            improvements: ""
+          await ctx.mcpManager.callTool("memory_log", {
+            session_id: sessionId,
+            role: msg.role,
+            content: msg.content.slice(0, 5e3)
           });
+        } catch {
         } finally {
           isHookCall = false;
         }
       }
-    }
-    if (ctx.config.autoSessionSave && messages.length > 2) {
       let lastUserMsg = "";
       for (let i = messages.length - 1; i >= 0; i--) {
         if (messages[i].role === "user" && typeof messages[i].content === "string") {
@@ -1122,14 +1078,97 @@ async function onSessionEnd(ctx, messages) {
           isHookCall = false;
         }
       }
+      console.log(pc2.dim(`  Saved ${textMessages.length} messages (session: ${sessionId})`));
+    }
+    if (ctx.config.evalPrompt) {
+      const rating = await p.select({
+        message: "Quick rating for this session?",
+        options: [
+          { value: "great", label: "Great" },
+          { value: "good", label: "Good" },
+          { value: "okay", label: "Okay" },
+          { value: "skip", label: "Skip" }
+        ],
+        initialValue: "skip"
+      });
+      if (!p.isCancel(rating) && rating !== "skip") {
+        try {
+          isHookCall = true;
+          await ctx.mcpManager.callTool("eval_log", {
+            rating,
+            highlights: "Quick session rating",
+            improvements: ""
+          });
+        } finally {
+          isHookCall = false;
+        }
+      }
     }
   } catch {
   }
 }
 
+// src/context-manager.ts
+function estimateMessageTokens(msg) {
+  if (typeof msg.content === "string") {
+    return Math.round(msg.content.split(/\s+/).filter(Boolean).length * 1.3);
+  }
+  let text2 = "";
+  for (const block of msg.content) {
+    if (block.type === "text") text2 += block.text;
+    else if (block.type === "tool_result") text2 += block.content;
+    else if (block.type === "tool_use") text2 += JSON.stringify(block.input);
+  }
+  return Math.round(text2.split(/\s+/).filter(Boolean).length * 1.3);
+}
+function estimateTotalTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    total += estimateMessageTokens(msg);
+  }
+  return total;
+}
+var MAX_CONVERSATION_TOKENS = 8e4;
+var KEEP_RECENT = 10;
+var KEEP_INITIAL = 2;
+function trimConversation(messages, _client) {
+  const totalTokens = estimateTotalTokens(messages);
+  if (totalTokens < MAX_CONVERSATION_TOKENS || messages.length <= KEEP_INITIAL + KEEP_RECENT) {
+    return;
+  }
+  const initial = messages.slice(0, KEEP_INITIAL);
+  const recent = messages.slice(-KEEP_RECENT);
+  const middle = messages.slice(KEEP_INITIAL, messages.length - KEEP_RECENT);
+  const summaryParts = [];
+  for (const msg of middle) {
+    if (typeof msg.content === "string" && msg.content.length > 0) {
+      const preview = msg.content.slice(0, 150);
+      summaryParts.push(`[${msg.role}]: ${preview}${msg.content.length > 150 ? "..." : ""}`);
+    }
+  }
+  const summaryText = `<conversation-summary>
+The following is a summary of ${middle.length} earlier messages that were compressed to save context:
+
+${summaryParts.slice(0, 20).join("\n")}
+${summaryParts.length > 20 ? `
+... and ${summaryParts.length - 20} more messages` : ""}
+</conversation-summary>`;
+  messages.length = 0;
+  messages.push(...initial);
+  messages.push({ role: "user", content: summaryText });
+  messages.push({ role: "assistant", content: "I have the context from our earlier conversation. Let's continue." });
+  messages.push(...recent);
+}
+
 // src/agent.ts
+function generateSessionId() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => n.toString().padStart(2, "0");
+  return `session-${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}`;
+}
 async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager, hooksConfig) {
   const messages = [];
+  const sessionId = generateSessionId();
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
@@ -1138,7 +1177,7 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager,
     if (mcpManager && hooksConfig) {
       try {
         const hookCtx = { mcpManager, config: hooksConfig };
-        await onSessionEnd(hookCtx, messages);
+        await onSessionEnd(hookCtx, messages, sessionId);
       } catch {
       }
     }
@@ -1176,11 +1215,10 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
     const cmdResult = await handleCommand(input, { model, mcpManager });
     if (cmdResult.handled) {
       if (cmdResult.quit) {
-        clearReminders();
         if (mcpManager && hooksConfig) {
           try {
             const hookCtx = { mcpManager, config: hooksConfig };
-            await onSessionEnd(hookCtx, messages);
+            await onSessionEnd(hookCtx, messages, sessionId);
           } catch {
           }
         }
@@ -1188,17 +1226,12 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
         rl.close();
         return;
       }
-      if (cmdResult.remind) {
-        const duration = setReminder(
-          cmdResult.remind.timeStr,
-          cmdResult.remind.message
-        );
-        if (duration) {
-          console.log(pc3.dim(`Reminder set for ${duration} from now.`));
-        } else {
-          console.log(
-            pc3.red("Invalid time format. Use: 5m, 30m, 1h, 2h, tomorrow")
-          );
+      if (cmdResult.saveConversation && mcpManager) {
+        try {
+          await saveConversationToMemory(mcpManager, messages, sessionId);
+          console.log(pc3.green("Conversation saved to memory."));
+        } catch {
+          console.log(pc3.red("Failed to save conversation."));
         }
         continue;
       }
@@ -1231,6 +1264,7 @@ ${wfMatch.steps}
       } catch {
       }
     }
+    trimConversation(messages, client);
     messages.push({ role: "user", content: input });
     process.stdout.write(pc3.cyan(`
 ${aiName} > `));
@@ -1308,127 +1342,28 @@ Error: ${message}`));
     }
   }
 }
-
-// src/scheduler.ts
-import fs5 from "fs";
-import path5 from "path";
-import os5 from "os";
-var SCHEDULES_PATH = path5.join(os5.homedir(), ".aman-agent", "schedules.json");
-function loadSchedules() {
-  if (!fs5.existsSync(SCHEDULES_PATH)) return [];
-  try {
-    return JSON.parse(fs5.readFileSync(SCHEDULES_PATH, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function saveSchedules(tasks) {
-  const dir = path5.dirname(SCHEDULES_PATH);
-  fs5.mkdirSync(dir, { recursive: true });
-  fs5.writeFileSync(
-    SCHEDULES_PATH,
-    JSON.stringify(tasks, null, 2) + "\n",
-    "utf-8"
-  );
-}
-function addSchedule(task) {
-  const tasks = loadSchedules();
-  const newTask = {
-    ...task,
-    id: Date.now().toString(36),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  tasks.push(newTask);
-  saveSchedules(tasks);
-  return newTask;
-}
-function removeSchedule(id) {
-  const tasks = loadSchedules();
-  const filtered = tasks.filter((t) => t.id !== id);
-  if (filtered.length === tasks.length) return false;
-  saveSchedules(filtered);
-  return true;
-}
-function getDueTasks() {
-  const tasks = loadSchedules();
-  const now = /* @__PURE__ */ new Date();
-  return tasks.filter((task) => {
-    if (!task.lastRun) return true;
-    const lastRun = new Date(task.lastRun);
-    return isDue(task.schedule, lastRun, now);
-  });
-}
-function isDue(schedule, lastRun, now) {
-  const hoursSinceLastRun = (now.getTime() - lastRun.getTime()) / (1e3 * 60 * 60);
-  if (schedule.startsWith("every ")) {
-    const match = schedule.match(/every (\d+)h/);
-    if (match) return hoursSinceLastRun >= parseInt(match[1]);
-  }
-  if (schedule === "daily" || schedule.startsWith("daily ")) {
-    return hoursSinceLastRun >= 20;
-  }
-  if (schedule === "weekdays" || schedule.startsWith("weekdays ")) {
-    const day = now.getDay();
-    return day >= 1 && day <= 5 && hoursSinceLastRun >= 20;
-  }
-  if (schedule.startsWith("weekly")) {
-    return hoursSinceLastRun >= 144;
-  }
-  return false;
-}
-
-// src/notifications.ts
-import fs6 from "fs";
-import path6 from "path";
-import os6 from "os";
-import pc4 from "picocolors";
-function checkNotifications() {
-  const notifications = [];
-  const dueTasks = getDueTasks();
-  for (const task of dueTasks) {
-    notifications.push({
-      type: "schedule",
-      message: `${task.name} (${task.schedule})`
-    });
-  }
-  const evalPath = path6.join(os6.homedir(), ".aeval", "eval.md");
-  if (fs6.existsSync(evalPath)) {
-    const content = fs6.readFileSync(evalPath, "utf-8");
-    const dateMatch = content.match(/- Last updated: (.+)$/m);
-    if (dateMatch) {
-      const lastDate = new Date(dateMatch[1]);
-      const daysSince = (Date.now() - lastDate.getTime()) / (1e3 * 60 * 60 * 24);
-      if (daysSince > 3) {
-        notifications.push({
-          type: "eval",
-          message: `No session logged in ${Math.floor(daysSince)} days \u2014 run /eval to log one`
-        });
-      }
+async function saveConversationToMemory(mcpManager, messages, sessionId) {
+  const recentMessages = messages.slice(-50);
+  for (const msg of recentMessages) {
+    if (typeof msg.content !== "string") continue;
+    try {
+      await mcpManager.callTool("memory_log", {
+        session_id: sessionId,
+        role: msg.role,
+        content: msg.content.slice(0, 5e3)
+      });
+    } catch {
     }
   }
-  return notifications;
-}
-function displayNotifications(notifications) {
-  if (notifications.length === 0) return;
-  console.log(
-    pc4.yellow(
-      `
-\u26A0 ${notifications.length} notification${notifications.length > 1 ? "s" : ""}:`
-    )
-  );
-  for (const n of notifications) {
-    console.log(`  - ${n.message}`);
-  }
-  console.log("");
 }
 
 // src/index.ts
-import fs7 from "fs";
-import path7 from "path";
-import os7 from "os";
+import fs5 from "fs";
+import path5 from "path";
+import os5 from "os";
 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(pc5.bold("aman agent") + pc5.dim(" \u2014 starting your AI companion"));
+  p2.intro(pc4.bold("aman agent") + pc4.dim(" \u2014 starting your AI companion"));
   let config = loadConfig();
   if (!config) {
     p2.log.info("First-time setup \u2014 configure your LLM connection.");
@@ -1459,7 +1394,7 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
       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(pc5.dim("Note: API access is separate from Claude Pro subscription. You need API credits."));
+      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
@@ -1525,28 +1460,26 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   const { prompt: systemPrompt, layers, truncated, totalTokens } = assembleSystemPrompt(budget);
   if (layers.length === 0) {
     p2.log.warning(
-      "No ecosystem configured. Run " + pc5.bold("npx @aman_asmuei/aman") + " first."
+      "No ecosystem configured. Run " + pc4.bold("npx @aman_asmuei/aman") + " first."
     );
     p2.log.info("Starting with empty system prompt.");
   } else {
     p2.log.success(
-      `Loaded: ${layers.join(", ")} ${pc5.dim(`(${totalTokens.toLocaleString()} tokens)`)}`
+      `Loaded: ${layers.join(", ")} ${pc4.dim(`(${totalTokens.toLocaleString()} tokens)`)}`
     );
     if (truncated.length > 0) {
-      p2.log.warning(`Truncated: ${truncated.join(", ")} ${pc5.dim("(over budget)")}`);
+      p2.log.warning(`Truncated: ${truncated.join(", ")} ${pc4.dim("(over budget)")}`);
     }
   }
-  p2.log.info(`Model: ${pc5.dim(model)}`);
-  const corePath = path7.join(os7.homedir(), ".acore", "core.md");
+  p2.log.info(`Model: ${pc4.dim(model)}`);
+  const corePath = path5.join(os5.homedir(), ".acore", "core.md");
   let aiName = "Assistant";
-  if (fs7.existsSync(corePath)) {
-    const content = fs7.readFileSync(corePath, "utf-8");
+  if (fs5.existsSync(corePath)) {
+    const content = fs5.readFileSync(corePath, "utf-8");
     const match = content.match(/^# (.+)$/m);
     if (match) aiName = match[1];
   }
-  p2.log.success(`${pc5.bold(aiName)} is ready.`);
-  const notifications = checkNotifications();
-  displayNotifications(notifications);
+  p2.log.success(`${pc4.bold(aiName)} is ready.`);
   const mcpManager = new McpManager();
   p2.log.step("Connecting to MCP servers...");
   await mcpManager.connect("aman", "npx", ["-y", "@aman_asmuei/aman-mcp"]);
@@ -1583,85 +1516,5 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   );
   await mcpManager.disconnect();
 });
-program.command("schedule").description("Manage scheduled tasks").argument("[action]", "add, list, or remove").argument("[id]", "task ID (for remove)").action(async (action, id) => {
-  if (!action || action === "list") {
-    const tasks = loadSchedules();
-    if (tasks.length === 0) {
-      console.log(pc5.dim("No scheduled tasks."));
-      return;
-    }
-    console.log(pc5.bold("Scheduled tasks:\n"));
-    for (const task of tasks) {
-      const lastRun = task.lastRun ? pc5.dim(` (last run: ${new Date(task.lastRun).toLocaleString()})`) : pc5.dim(" (never run)");
-      console.log(
-        `  ${pc5.cyan(task.id)}  ${task.name}  ${pc5.dim(task.schedule)}  [${task.mode}]${lastRun}`
-      );
-    }
-    return;
-  }
-  if (action === "add") {
-    const name = await p2.text({
-      message: "Task name?",
-      validate: (v) => v.length === 0 ? "Name is required" : void 0
-    });
-    if (p2.isCancel(name)) return;
-    const schedule = await p2.select({
-      message: "Schedule?",
-      options: [
-        { value: "daily 9am", label: "Daily at 9am" },
-        { value: "weekdays 9am", label: "Weekdays at 9am" },
-        { value: "weekly friday 4pm", label: "Weekly Friday 4pm" },
-        { value: "every 2h", label: "Every 2 hours" },
-        { value: "every 4h", label: "Every 4 hours" }
-      ]
-    });
-    if (p2.isCancel(schedule)) return;
-    const actionType = await p2.select({
-      message: "What should happen?",
-      options: [
-        { value: "notify", label: "Show notification" },
-        { value: "auto-run", label: "Run automatically" }
-      ]
-    });
-    if (p2.isCancel(actionType)) return;
-    let taskAction = "notify";
-    if (actionType === "auto-run") {
-      const cmd = await p2.text({
-        message: "Command to run?",
-        placeholder: "e.g. run:daily-standup",
-        validate: (v) => v.length === 0 ? "Command is required" : void 0
-      });
-      if (p2.isCancel(cmd)) return;
-      taskAction = cmd;
-    }
-    const task = addSchedule({
-      name,
-      schedule,
-      action: taskAction,
-      mode: actionType
-    });
-    console.log(
-      pc5.green(`
-Scheduled task created: ${pc5.bold(task.name)} (${task.id})`)
-    );
-    return;
-  }
-  if (action === "remove") {
-    if (!id) {
-      console.log(pc5.red("Usage: aman-agent schedule remove <id>"));
-      return;
-    }
-    const removed = removeSchedule(id);
-    if (removed) {
-      console.log(pc5.green(`Task ${id} removed.`));
-    } else {
-      console.log(pc5.red(`Task ${id} not found.`));
-    }
-    return;
-  }
-  console.log(
-    pc5.red(`Unknown action: ${action}. Use add, list, or remove.`)
-  );
-});
 program.parse();
 //# sourceMappingURL=index.js.map