@aman_asmuei/aman-agent 0.21.0 → 0.22.0

package/dist/index.js

@@ -952,135 +952,244 @@ function createClaudeCodeClient(model) {
 }
 
 // src/llm/copilot.ts
-import OpenAI3 from "openai";
-import { execFileSync as execFileSync2 } from "child_process";
-var GITHUB_MODELS_BASE_URL = "https://models.inference.ai.azure.com";
-function isGhCliInstalled() {
+import { spawn as spawn2, execFileSync as execFileSync2 } from "child_process";
+function isCopilotCliInstalled() {
   try {
-    execFileSync2("which", ["gh"], { stdio: "ignore" });
+    execFileSync2("which", ["copilot"], { stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
-function isGhAuthenticated() {
+function isCopilotCliAuthenticated() {
   try {
-    const result = execFileSync2("gh", ["auth", "status"], {
-      stdio: ["ignore", "pipe", "pipe"],
+    const result = execFileSync2("copilot", ["--version"], {
+      stdio: ["ignore", "pipe", "ignore"],
       timeout: 5e3
     });
-    return true;
+    return result.toString().trim().length > 0;
   } catch {
     return false;
   }
 }
-function getGhToken() {
-  try {
-    const token = execFileSync2("gh", ["auth", "token"], {
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: 5e3
-    }).toString().trim();
-    if (!token) {
-      throw new Error("No token returned from gh auth token");
+function extractText2(content) {
+  if (typeof content === "string") return content;
+  return content.map((block) => {
+    if (block.type === "text") return block.text;
+    if (block.type === "tool_result")
+      return `[Tool result for ${block.tool_use_id}]: ${block.content}`;
+    if (block.type === "tool_use") return `[Used tool: ${block.name}]`;
+    return "";
+  }).filter(Boolean).join("\n");
+}
+function formatConversation2(systemPrompt, messages, tools) {
+  const parts = [];
+  let fullSystem = systemPrompt;
+  if (tools && tools.length > 0) {
+    fullSystem += "\n\n## Available Tools\n";
+    fullSystem += "You have access to the following tools. To use a tool, respond with a JSON block in this exact format:\n";
+    fullSystem += '```json\n{"tool_use": {"id": "call_1", "name": "tool_name", "input": {\u2026}}}\n```\n\n';
+    for (const tool of tools) {
+      fullSystem += `### ${tool.name}
+${tool.description}
+Parameters: ${JSON.stringify(tool.input_schema)}
+
+`;
     }
-    return token;
-  } catch {
-    throw new Error(
-      "Failed to get GitHub token. Run: gh auth login"
-    );
+    fullSystem += "You may include multiple tool_use blocks. After each tool use, you will receive the result and can continue.\n";
+  }
+  if (messages.length > 1) {
+    parts.push("<conversation_history>");
+    for (let i = 0; i < messages.length - 1; i++) {
+      const msg = messages[i];
+      const role = msg.role === "user" ? "User" : "Assistant";
+      const text3 = extractText2(msg.content);
+      parts.push(`[${role}]: ${text3}`);
+    }
+    parts.push("</conversation_history>\n");
   }
+  const lastMsg = messages[messages.length - 1];
+  if (lastMsg) {
+    parts.push(extractText2(lastMsg.content));
+  }
+  return { prompt: parts.join("\n"), systemPrompt: fullSystem };
+}
+function parseToolUses2(text3) {
+  const toolUses = [];
+  const codeBlockRegex = /```json\s*\n?([\s\S]*?)```/g;
+  let match;
+  while ((match = codeBlockRegex.exec(text3)) !== null) {
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      if (parsed.tool_use) {
+        toolUses.push({
+          id: parsed.tool_use.id || `call_${toolUses.length + 1}`,
+          name: parsed.tool_use.name,
+          input: parsed.tool_use.input || {}
+        });
+      }
+    } catch {
+    }
+  }
+  if (toolUses.length === 0) {
+    const inlineRegex = /\{"tool_use"\s*:\s*\{[^}]*"name"\s*:\s*"[^"]+?"[^}]*\}\s*\}/g;
+    while ((match = inlineRegex.exec(text3)) !== null) {
+      try {
+        const parsed = JSON.parse(match[0]);
+        if (parsed.tool_use) {
+          toolUses.push({
+            id: parsed.tool_use.id || `call_${toolUses.length + 1}`,
+            name: parsed.tool_use.name,
+            input: parsed.tool_use.input || {}
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return toolUses;
 }
 function createCopilotClient(model) {
   return {
     async chat(systemPrompt, messages, onChunk, tools, options) {
-      const token = getGhToken();
-      const client = new OpenAI3({
-        baseURL: GITHUB_MODELS_BASE_URL,
-        apiKey: token
-      });
-      const openaiMessages = toOpenAICompatibleMessages(systemPrompt, messages);
-      const hasTools = tools && tools.length > 0;
-      try {
+      const { prompt, systemPrompt: fullSystem } = formatConversation2(
+        systemPrompt,
+        messages,
+        tools
+      );
+      return new Promise((resolve, reject) => {
+        const args = [
+          "--print",
+          "--output-format",
+          "json",
+          "--silent",
+          "--no-custom-instructions"
+        ];
+        if (model) {
+          args.push("--model", model);
+        }
+        args.push(prompt);
+        const proc = spawn2("copilot", args, {
+          stdio: ["pipe", "pipe", "pipe"],
+          env: {
+            ...process.env,
+            COPILOT_SYSTEM_PROMPT: fullSystem
+          }
+        });
         let fullText = "";
-        const toolCallAccumulators = /* @__PURE__ */ new Map();
-        const createParams = {
-          model,
-          max_tokens: options?.maxOutputTokens ?? 8192,
-          messages: openaiMessages,
-          stream: true
-        };
-        if (hasTools) {
-          createParams.tools = tools.map((t) => ({
-            type: "function",
-            function: {
-              name: t.name,
-              description: t.description,
-              parameters: t.input_schema
+        let buffer = "";
+        let stderrOutput = "";
+        proc.stdout.on("data", (data) => {
+          buffer += data.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const event = JSON.parse(line);
+              if (event.type === "assistant" && event.content) {
+                fullText += event.content;
+                onChunk({ type: "text", text: event.content });
+              } else if (event.type === "message" && event.message?.content) {
+                for (const block of event.message.content) {
+                  if (block.type === "text" && block.text) {
+                    fullText += block.text;
+                    onChunk({ type: "text", text: block.text });
+                  }
+                }
+              } else if (event.type === "content_block_delta") {
+                if (event.delta?.type === "text_delta" && event.delta.text) {
+                  fullText += event.delta.text;
+                  onChunk({ type: "text", text: event.delta.text });
+                }
+              } else if (event.role === "assistant" && event.content) {
+                const text3 = typeof event.content === "string" ? event.content : event.content.map((b) => b.text || "").join("");
+                if (text3) {
+                  fullText += text3;
+                  onChunk({ type: "text", text: text3 });
+                }
+              }
+            } catch {
+              if (line.trim()) {
+                fullText += line;
+                onChunk({ type: "text", text: line });
+              }
             }
-          }));
-        }
-        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 });
           }
-          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);
+        });
+        proc.stderr.on("data", (data) => {
+          stderrOutput += data.toString();
+        });
+        proc.on("close", (code) => {
+          if (buffer.trim()) {
+            try {
+              const event = JSON.parse(buffer);
+              if (event.type === "assistant" && event.content) {
+                fullText += event.content;
+                onChunk({ type: "text", text: event.content });
+              } else if (event.role === "assistant" && typeof event.content === "string") {
+                fullText += event.content;
+                onChunk({ type: "text", text: event.content });
+              }
+            } catch {
+              if (buffer.trim()) {
+                fullText += buffer;
+                onChunk({ type: "text", text: buffer });
               }
-              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;
             }
           }
-        }
-        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: contentBlocks },
-            toolUses
-          };
-        }
-        return {
-          message: { role: "assistant", content: fullText },
-          toolUses: []
-        };
-      } catch (error) {
-        if (error instanceof OpenAI3.AuthenticationError) {
-          throw new Error(
-            "GitHub authentication failed. Run: gh auth login"
-          );
-        }
-        if (error instanceof OpenAI3.RateLimitError) {
-          throw new Error(
-            "Rate limited by GitHub Models. Copilot subscribers get higher limits."
-          );
-        }
-        throw error;
-      }
+          onChunk({ type: "done" });
+          if (code !== 0 && !fullText) {
+            reject(
+              new Error(
+                `Copilot CLI exited with code ${code}${stderrOutput ? `: ${stderrOutput.trim()}` : ""}`
+              )
+            );
+            return;
+          }
+          const hasTools = tools && tools.length > 0;
+          if (hasTools) {
+            const toolUses = parseToolUses2(fullText);
+            if (toolUses.length > 0) {
+              let cleanText = fullText;
+              const stripRegex = /```json\s*\n?\s*\{"tool_use"[\s\S]*?```/g;
+              cleanText = cleanText.replace(stripRegex, "").trim();
+              const contentBlocks = [];
+              if (cleanText) {
+                contentBlocks.push({ type: "text", text: cleanText });
+              }
+              for (const tu of toolUses) {
+                contentBlocks.push({
+                  type: "tool_use",
+                  id: tu.id,
+                  name: tu.name,
+                  input: tu.input
+                });
+              }
+              resolve({
+                message: { role: "assistant", content: contentBlocks },
+                toolUses
+              });
+              return;
+            }
+          }
+          resolve({
+            message: { role: "assistant", content: fullText },
+            toolUses: []
+          });
+        });
+        proc.on("error", (err) => {
+          if (err.code === "ENOENT") {
+            reject(
+              new Error(
+                "Copilot CLI not found. Install it from: https://docs.github.com/copilot/how-tos/copilot-cli"
+              )
+            );
+          } else {
+            reject(err);
+          }
+        });
+      });
     }
   };
 }
@@ -3184,6 +3293,17 @@ function progressBar(pct) {
 }
 
 // src/commands.ts
+import {
+  getIdentity as acoreGetIdentity,
+  updateSection as acoreUpdateSection
+} from "@aman_asmuei/acore-core";
+import {
+  listRuleCategories as arulesListCategories,
+  addRule as arulesAddRule,
+  removeRule as arulesRemoveRule,
+  toggleRuleAt as arulesToggleRule
+} from "@aman_asmuei/arules-core";
+var AGENT_SCOPE = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
 function readEcosystemFile(filePath, label) {
   if (!fs12.existsSync(filePath)) {
     return pc5.dim(`No ${label} file found at ${filePath}`);
@@ -3209,17 +3329,26 @@ async function mcpWrite(ctx, layer, tool, args) {
   }
   return pc5.green(result);
 }
-async function handleIdentityCommand(action, args, ctx) {
-  const home2 = os11.homedir();
+async function handleIdentityCommand(action, args, _ctx) {
   if (!action) {
-    const content = readEcosystemFile(path12.join(home2, ".acore", "core.md"), "identity (acore)");
-    return { handled: true, output: content };
+    const identity = await acoreGetIdentity(AGENT_SCOPE);
+    if (!identity) {
+      return {
+        handled: true,
+        output: pc5.dim(
+          `No identity configured for ${AGENT_SCOPE}. Run: npx @aman_asmuei/acore`
+        )
+      };
+    }
+    return { handled: true, output: identity.content.trim() };
   }
   if (action === "update") {
     if (args.length === 0) {
       return {
         handled: true,
-        output: pc5.yellow("Usage: /identity update <section>\nTip: describe changes in natural language and the AI will update via MCP.")
+        output: pc5.yellow(
+          "Usage: /identity update <section>\nTip: describe changes in natural language and the AI will update via acore-core."
+        )
       };
     }
     const section = args[0];
@@ -3227,60 +3356,161 @@ async function handleIdentityCommand(action, args, ctx) {
     if (!content) {
       return {
         handled: true,
-        output: pc5.yellow("Usage: /identity update <section> <new content...>\nExample: /identity update Personality Warm, curious, and direct.")
+        output: pc5.yellow(
+          "Usage: /identity update <section> <new content...>\nExample: /identity update Personality Warm, curious, and direct."
+        )
+      };
+    }
+    try {
+      await acoreUpdateSection(section, content, AGENT_SCOPE);
+      return { handled: true, output: pc5.green(`Updated section: ${section}`) };
+    } catch (err) {
+      return {
+        handled: true,
+        output: pc5.red(
+          `Failed to update ${section}: ${err instanceof Error ? err.message : String(err)}`
+        )
       };
     }
-    const output = await mcpWrite(ctx, "identity", "identity_update_section", { section, content });
-    return { handled: true, output };
   }
   if (action === "help") {
-    return { handled: true, output: [
-      pc5.bold("Identity commands:"),
-      `  ${pc5.cyan("/identity")}                  View current identity`,
-      `  ${pc5.cyan("/identity update")} <section>  Update a section`
-    ].join("\n") };
+    return {
+      handled: true,
+      output: [
+        pc5.bold("Identity commands:"),
+        `  ${pc5.cyan("/identity")}                  View current identity`,
+        `  ${pc5.cyan("/identity update")} <section>  Update a section`
+      ].join("\n")
+    };
   }
-  return { handled: true, output: pc5.yellow(`Unknown action: /identity ${action}. Try /identity --help`) };
+  return {
+    handled: true,
+    output: pc5.yellow(
+      `Unknown action: /identity ${action}. Try /identity --help`
+    )
+  };
 }
-async function handleRulesCommand(action, args, ctx) {
-  const home2 = os11.homedir();
+async function handleRulesCommand(action, args, _ctx) {
   if (!action) {
-    const content = readEcosystemFile(path12.join(home2, ".arules", "rules.md"), "guardrails (arules)");
-    return { handled: true, output: content };
+    const cats = await arulesListCategories(AGENT_SCOPE);
+    if (cats.length === 0) {
+      return {
+        handled: true,
+        output: pc5.dim(
+          `No rules configured for ${AGENT_SCOPE}. Run: npx @aman_asmuei/arules`
+        )
+      };
+    }
+    const lines = [];
+    for (const cat of cats) {
+      lines.push(pc5.bold(`## ${cat.name}`));
+      for (const rule of cat.rules) {
+        lines.push(`  - ${rule}`);
+      }
+      lines.push("");
+    }
+    return { handled: true, output: lines.join("\n").trim() };
   }
   if (action === "add") {
     if (args.length < 2) {
-      return { handled: true, output: pc5.yellow("Usage: /rules add <category> <rule text...>") };
+      return {
+        handled: true,
+        output: pc5.yellow("Usage: /rules add <category> <rule text...>")
+      };
     }
     const category = args[0];
     const rule = args.slice(1).join(" ");
-    const output = await mcpWrite(ctx, "rules", "rules_add", { category, rule });
-    return { handled: true, output };
+    try {
+      await arulesAddRule(category, rule, AGENT_SCOPE);
+      return {
+        handled: true,
+        output: pc5.green(`Added rule to "${category}": ${rule}`)
+      };
+    } catch (err) {
+      return {
+        handled: true,
+        output: pc5.red(
+          `Failed: ${err instanceof Error ? err.message : String(err)}`
+        )
+      };
+    }
   }
   if (action === "remove") {
     if (args.length < 2) {
-      return { handled: true, output: pc5.yellow("Usage: /rules remove <category> <index>") };
+      return {
+        handled: true,
+        output: pc5.yellow("Usage: /rules remove <category> <index>")
+      };
+    }
+    const category = args[0];
+    const idx = parseInt(args[1], 10);
+    if (isNaN(idx) || idx < 1) {
+      return {
+        handled: true,
+        output: pc5.yellow("Index must be a positive integer.")
+      };
+    }
+    try {
+      await arulesRemoveRule(category, idx, AGENT_SCOPE);
+      return {
+        handled: true,
+        output: pc5.green(`Removed rule ${idx} from "${category}"`)
+      };
+    } catch (err) {
+      return {
+        handled: true,
+        output: pc5.red(
+          `Failed: ${err instanceof Error ? err.message : String(err)}`
+        )
+      };
     }
-    const output = await mcpWrite(ctx, "rules", "rules_remove", { category: args[0], index: parseInt(args[1], 10) });
-    return { handled: true, output };
   }
   if (action === "toggle") {
     if (args.length < 2) {
-      return { handled: true, output: pc5.yellow("Usage: /rules toggle <category> <index>") };
+      return {
+        handled: true,
+        output: pc5.yellow("Usage: /rules toggle <category> <index>")
+      };
+    }
+    const category = args[0];
+    const idx = parseInt(args[1], 10);
+    if (isNaN(idx) || idx < 1) {
+      return {
+        handled: true,
+        output: pc5.yellow("Index must be a positive integer.")
+      };
+    }
+    try {
+      await arulesToggleRule(category, idx, AGENT_SCOPE);
+      return {
+        handled: true,
+        output: pc5.green(`Toggled rule ${idx} in "${category}"`)
+      };
+    } catch (err) {
+      return {
+        handled: true,
+        output: pc5.red(
+          `Failed: ${err instanceof Error ? err.message : String(err)}`
+        )
+      };
     }
-    const output = await mcpWrite(ctx, "rules", "rules_toggle", { category: args[0], index: parseInt(args[1], 10) });
-    return { handled: true, output };
   }
   if (action === "help") {
-    return { handled: true, output: [
-      pc5.bold("Rules commands:"),
-      `  ${pc5.cyan("/rules")}                         View current rules`,
-      `  ${pc5.cyan("/rules add")} <category> <text>    Add a rule`,
-      `  ${pc5.cyan("/rules remove")} <category> <idx>  Remove a rule`,
-      `  ${pc5.cyan("/rules toggle")} <category> <idx>  Toggle a rule`
-    ].join("\n") };
+    return {
+      handled: true,
+      output: [
+        pc5.bold("Rules commands:"),
+        `  ${pc5.cyan("/rules")}                         View current rules`,
+        `  ${pc5.cyan("/rules add")} <category> <text>    Add a rule`,
+        `  ${pc5.cyan("/rules remove")} <category> <idx>  Remove a rule`,
+        `  ${pc5.cyan("/rules toggle")} <category> <idx>  Toggle a rule`
+      ].join("\n")
+    };
   }
-  return { handled: true, output: pc5.yellow(`Unknown action: /rules ${action}. Try /rules --help`) };
+  return {
+    handled: true,
+    output: pc5.yellow(`Unknown action: /rules ${action}. Try /rules --help`)
+  };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
   const home2 = os11.homedir();
@@ -3312,205 +3542,29 @@ async function handleWorkflowsCommand(action, args, ctx) {
   }
   return { handled: true, output: pc5.yellow(`Unknown action: /workflows ${action}. Try /workflows --help`) };
 }
-var AKIT_REGISTRY = [
-  { name: "web-search", description: "Search the web for current information", category: "search", mcp: { package: "@anthropic/web-search", command: "npx", args: ["-y", "@anthropic/web-search"] } },
-  { name: "brave-search", description: "Private web search via Brave", category: "search", mcp: { package: "@modelcontextprotocol/server-brave-search", command: "npx", args: ["-y", "@modelcontextprotocol/server-brave-search"], env: { BRAVE_API_KEY: "" } }, envHint: "Set BRAVE_API_KEY from https://brave.com/search/api/" },
-  { name: "github", description: "Manage GitHub repos, PRs, issues", category: "development", mcp: { package: "@modelcontextprotocol/server-github", command: "npx", args: ["-y", "@modelcontextprotocol/server-github"], env: { GITHUB_TOKEN: "" } }, envHint: "Set GITHUB_TOKEN from https://github.com/settings/tokens" },
-  { name: "git", description: "Git operations \u2014 log, diff, blame, branch", category: "development", mcp: { package: "@modelcontextprotocol/server-git", command: "npx", args: ["-y", "@modelcontextprotocol/server-git"] } },
-  { name: "filesystem", description: "Read, write, and search files", category: "development", mcp: { package: "@modelcontextprotocol/server-filesystem", command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "."] } },
-  { name: "linear", description: "Manage Linear issues and projects", category: "development", mcp: { package: "@linear/mcp-server", command: "npx", args: ["-y", "@linear/mcp-server"], env: { LINEAR_API_KEY: "" } }, envHint: "Set LINEAR_API_KEY from Linear settings \u2192 API" },
-  { name: "sentry", description: "Monitor and triage app errors", category: "development", mcp: { package: "@sentry/mcp-server", command: "npx", args: ["-y", "@sentry/mcp-server"], env: { SENTRY_AUTH_TOKEN: "" } }, envHint: "Set SENTRY_AUTH_TOKEN from Sentry settings \u2192 API keys" },
-  { name: "postgres", description: "Query PostgreSQL databases", category: "data", mcp: { package: "@modelcontextprotocol/server-postgres", command: "npx", args: ["-y", "@modelcontextprotocol/server-postgres"], env: { DATABASE_URL: "" } }, envHint: "Set DATABASE_URL (e.g., postgresql://user:pass@localhost/db)" },
-  { name: "sqlite", description: "Query local SQLite databases", category: "data", mcp: { package: "@modelcontextprotocol/server-sqlite", command: "npx", args: ["-y", "@modelcontextprotocol/server-sqlite"] } },
-  { name: "fetch", description: "HTTP requests to APIs", category: "automation", mcp: { package: "@modelcontextprotocol/server-fetch", command: "npx", args: ["-y", "@modelcontextprotocol/server-fetch"] } },
-  { name: "puppeteer", description: "Browser automation and scraping", category: "automation", mcp: { package: "@modelcontextprotocol/server-puppeteer", command: "npx", args: ["-y", "@modelcontextprotocol/server-puppeteer"] } },
-  { name: "docker", description: "Manage Docker containers", category: "automation", mcp: { package: "@modelcontextprotocol/server-docker", command: "npx", args: ["-y", "@modelcontextprotocol/server-docker"] } },
-  { name: "slack", description: "Send and read Slack messages", category: "communication", mcp: { package: "@modelcontextprotocol/server-slack", command: "npx", args: ["-y", "@modelcontextprotocol/server-slack"], env: { SLACK_BOT_TOKEN: "" } }, envHint: "Set SLACK_BOT_TOKEN from your Slack app settings" },
-  { name: "notion", description: "Read and write Notion pages", category: "communication", mcp: { package: "@notionhq/notion-mcp-server", command: "npx", args: ["-y", "@notionhq/notion-mcp-server"], env: { NOTION_API_KEY: "" } }, envHint: "Set NOTION_API_KEY from https://notion.so/my-integrations" },
-  { name: "social", description: "Post to Bluesky, X/Twitter, Threads", category: "communication", mcp: { package: "@aman_asmuei/aman-social", command: "npx", args: ["-y", "@aman_asmuei/aman-social"] }, envHint: "Set BLUESKY_HANDLE + BLUESKY_APP_PASSWORD, TWITTER_API_KEY + secrets, or THREADS_ACCESS_TOKEN" },
-  { name: "memory", description: "Persistent AI memory via amem", category: "memory", mcp: { package: "@aman_asmuei/amem", command: "npx", args: ["-y", "@aman_asmuei/amem"] } },
-  { name: "docling", description: "Convert PDF, DOCX, PPTX, XLSX to markdown", category: "documents", mcp: { package: "docling-mcp", command: "uvx", args: ["docling-mcp"] }, envHint: "Requires Python 3.10+. Install: pip install docling" }
-];
-function loadAkitInstalled() {
-  const filePath = path12.join(os11.homedir(), ".akit", "installed.json");
-  if (!fs12.existsSync(filePath)) return [];
-  try {
-    return JSON.parse(fs12.readFileSync(filePath, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function saveAkitInstalled(tools) {
-  const dir = path12.join(os11.homedir(), ".akit");
-  fs12.mkdirSync(dir, { recursive: true });
-  fs12.writeFileSync(path12.join(dir, "installed.json"), JSON.stringify(tools, null, 2) + "\n", "utf-8");
-}
-function addToAmanAgentConfig(name, mcpConfig) {
-  const configPath = path12.join(os11.homedir(), ".aman-agent", "config.json");
-  if (!fs12.existsSync(configPath)) return;
-  try {
-    const config = JSON.parse(fs12.readFileSync(configPath, "utf-8"));
-    if (!config.mcpServers) config.mcpServers = {};
-    config.mcpServers[name] = mcpConfig;
-    fs12.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  } catch {
-  }
-}
-function removeFromAmanAgentConfig(name) {
-  const configPath = path12.join(os11.homedir(), ".aman-agent", "config.json");
-  if (!fs12.existsSync(configPath)) return;
-  try {
-    const config = JSON.parse(fs12.readFileSync(configPath, "utf-8"));
-    if (config.mcpServers) {
-      delete config.mcpServers[name];
-      fs12.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-    }
-  } catch {
-  }
-}
-function handleAkitCommand(action, args) {
-  const installed = loadAkitInstalled();
-  const installedNames = new Set(installed.map((t) => t.name));
-  if (action === "add") {
-    const available2 = AKIT_REGISTRY.filter((t) => !installedNames.has(t.name));
-    if (args.length < 1) {
-      if (available2.length === 0) {
-        return { handled: true, output: pc5.green("All tools are installed!") };
-      }
-      const lines3 = [pc5.bold("Select a tool to install:"), ""];
-      available2.forEach((tool2, i) => {
-        const num2 = pc5.cyan(String(i + 1).padStart(2));
-        lines3.push(`  ${num2}  ${tool2.name.padEnd(16)} ${pc5.dim(tool2.description)}`);
-      });
-      lines3.push("");
-      lines3.push(`  Type: ${pc5.cyan("/akit add <number>")} or ${pc5.cyan("/akit add <name>")}`);
-      lines3.push(`  Custom: ${pc5.cyan("/akit add custom <name> <command> <args...>")}`);
-      return { handled: true, output: lines3.join("\n") };
-    }
-    if (args[0].toLowerCase() === "custom") {
-      if (args.length < 3) {
-        return { handled: true, output: pc5.yellow("Usage: /akit add custom <name> <command> <args...>\nExample: /akit add custom my-tool npx -y @org/my-mcp-server") };
-      }
-      const customName = args[1];
-      const customCommand = args[2];
-      const customArgs = args.slice(3);
-      if (installedNames.has(customName)) {
-        return { handled: true, output: pc5.yellow(`${customName} is already installed.`) };
-      }
-      installed.push({
-        name: customName,
-        installedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-        mcpConfigured: true
-      });
-      saveAkitInstalled(installed);
-      addToAmanAgentConfig(customName, { command: customCommand, args: customArgs });
-      return {
-        handled: true,
-        output: [
-          pc5.green(`\u2713 Added ${pc5.bold(customName)}`) + pc5.dim(` (custom MCP: ${customCommand} ${customArgs.join(" ")})`),
-          pc5.dim("  Restart aman-agent to load the new tool.")
-        ].join("\n")
-      };
-    }
-    const input = args[0].toLowerCase();
-    let tool;
-    const num = parseInt(input, 10);
-    if (!isNaN(num) && num >= 1 && num <= available2.length) {
-      tool = available2[num - 1];
-    } else {
-      tool = AKIT_REGISTRY.find((t) => t.name === input);
-    }
-    if (!tool) {
-      return {
-        handled: true,
-        output: [
-          pc5.red(`Tool "${input}" not found.`),
-          `Type ${pc5.cyan("/akit add")} to see available tools.`
-        ].join("\n")
-      };
-    }
-    if (installedNames.has(tool.name)) {
-      return { handled: true, output: pc5.yellow(`${tool.name} is already installed.`) };
-    }
-    installed.push({
-      name: tool.name,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-      mcpConfigured: tool.mcp !== null
-    });
-    saveAkitInstalled(installed);
-    if (tool.mcp) {
-      addToAmanAgentConfig(tool.name, {
-        command: tool.mcp.command,
-        args: tool.mcp.args
-      });
-    }
-    const lines2 = [
-      pc5.green(`\u2713 Added ${pc5.bold(tool.name)}`) + (tool.mcp ? pc5.dim(` (MCP: ${tool.mcp.package})`) : "")
-    ];
-    if (tool.envHint) {
-      lines2.push(pc5.yellow(`  \u26A0 ${tool.envHint}`));
-    }
-    if (tool.mcp) {
-      lines2.push(pc5.dim("  Restart aman-agent to load the new tool."));
-    }
-    return { handled: true, output: lines2.join("\n") };
-  }
-  if (action === "remove") {
-    if (args.length < 1) {
-      return { handled: true, output: pc5.yellow("Usage: /akit remove <tool>") };
-    }
-    const toolName = args[0].toLowerCase();
-    if (!installedNames.has(toolName)) {
-      return { handled: true, output: pc5.red(`${toolName} is not installed.`) };
-    }
-    const updated = installed.filter((t) => t.name !== toolName);
-    saveAkitInstalled(updated);
-    removeFromAmanAgentConfig(toolName);
-    return {
-      handled: true,
-      output: pc5.green(`\u2713 Removed ${pc5.bold(toolName)}`) + pc5.dim("  (restart aman-agent to apply)")
-    };
-  }
-  if (action === "help") {
-    return {
-      handled: true,
-      output: [
-        pc5.bold("akit \u2014 Tool Management"),
-        "",
-        `  ${pc5.cyan("/akit")}               List installed & available tools`,
-        `  ${pc5.cyan("/akit add <tool>")}     Install a tool`,
-        `  ${pc5.cyan("/akit remove <tool>")}  Uninstall a tool`
-      ].join("\n")
-    };
-  }
-  const available = AKIT_REGISTRY.filter((t) => !installedNames.has(t.name));
-  const lines = [pc5.bold("akit \u2014 AI Tool Manager"), ""];
-  if (installed.length > 0) {
-    lines.push(`  ${pc5.bold(`Installed (${installed.length})`)}`);
-    for (const tool of installed) {
-      const mcp = tool.mcpConfigured ? pc5.green("MCP") : pc5.dim("manual");
-      lines.push(`  ${pc5.green("\u25CF")} ${pc5.bold(tool.name.padEnd(16))} ${mcp}  ${pc5.dim(tool.installedAt)}`);
-    }
-    lines.push("");
-  }
-  if (available.length > 0) {
-    lines.push(`  ${pc5.bold(`Available (${available.length})`)}`);
-    const byCategory = /* @__PURE__ */ new Map();
-    for (const tool of available) {
-      if (!byCategory.has(tool.category)) byCategory.set(tool.category, []);
-      byCategory.get(tool.category).push(tool);
-    }
-    for (const [category, tools] of byCategory) {
-      lines.push(`  ${pc5.dim(category)}`);
-      for (const tool of tools) {
-        lines.push(`  ${pc5.dim("\u25CB")} ${tool.name.padEnd(16)} ${pc5.dim(tool.description)}`);
-      }
-    }
-    lines.push("");
-  }
-  lines.push(`  ${pc5.cyan("/akit add <tool>")}     Install a tool`);
-  lines.push(`  ${pc5.cyan("/akit remove <tool>")}  Uninstall a tool`);
-  return { handled: true, output: lines.join("\n") };
+function handleAkitCommand(_action, _args) {
+  return {
+    handled: true,
+    output: [
+      pc5.bold("akit \u2014 Tool Management"),
+      "",
+      pc5.dim(
+        "Tool management is now handled by the standalone akit CLI rather than"
+      ),
+      pc5.dim(
+        "duplicated inside aman-agent. The akit slash command is informational only."
+      ),
+      "",
+      `  ${pc5.cyan("npx @aman_asmuei/akit list")}              List installed tools`,
+      `  ${pc5.cyan("npx @aman_asmuei/akit search <query>")}    Search the tool registry`,
+      `  ${pc5.cyan("npx @aman_asmuei/akit add <tool>")}        Install a tool`,
+      `  ${pc5.cyan("npx @aman_asmuei/akit remove <tool>")}     Uninstall a tool`,
+      "",
+      pc5.dim(
+        "Restart aman-agent after installing/removing tools to pick up changes."
+      )
+    ].join("\n")
+  };
 }
 async function handleSkillsCommand(action, args, ctx) {
   const home2 = os11.homedir();
@@ -3914,7 +3968,7 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.21.0" : "unknown";
+    const local = true ? "0.22.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc5.green("Up to date")} \u2014 v${local}` };
     }
@@ -6369,7 +6423,7 @@ function bootstrapEcosystem() {
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.21.0").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.22.0").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) => {
   p3.intro(pc8.bold("aman agent") + pc8.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -6491,68 +6545,68 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
             `  ${pc8.cyan("Business")}      $19/user/mo Team admin + policy controls`,
             `  ${pc8.cyan("Enterprise")}    $39/user/mo SSO, audit logs, IP indemnity`,
             "",
-            `${pc8.dim("Authentication is handled by the GitHub CLI (gh).")}`,
+            `${pc8.dim("Authentication is handled by the Copilot CLI.")}`,
             `${pc8.dim("Subscribe at: https://github.com/features/copilot")}`
           ].join("\n"),
           "Copilot Plans"
         );
-        if (!isGhCliInstalled()) {
-          p3.log.error("GitHub CLI (gh) is not installed.");
+        if (!isCopilotCliInstalled()) {
+          p3.log.error("Copilot CLI is not installed.");
           p3.log.info("Install it from:");
-          p3.log.step(pc8.bold("https://cli.github.com"));
+          p3.log.step(pc8.bold("https://docs.github.com/copilot/how-tos/copilot-cli"));
           p3.log.info(pc8.dim("Then re-run aman-agent to continue setup."));
           process.exit(1);
         }
-        p3.log.success("GitHub CLI detected.");
-        const ghAuth = isGhAuthenticated();
-        if (ghAuth) {
-          p3.log.success("GitHub authentication found.");
+        p3.log.success("Copilot CLI detected.");
+        const copilotAuth = isCopilotCliAuthenticated();
+        if (copilotAuth) {
+          p3.log.success("Copilot authentication found.");
         } else {
-          p3.log.warn("Not logged in to GitHub.");
+          p3.log.warn("Not logged in to Copilot.");
           const authAction = await p3.select({
             message: "Authentication",
             options: [
-              { value: "login", label: "Log in now", hint: "runs: gh auth login" },
+              { value: "login", label: "Log in now", hint: "runs: copilot login" },
               { value: "skip", label: "Skip (I'll log in later)" }
             ]
           });
           if (p3.isCancel(authAction)) process.exit(0);
           if (authAction === "login") {
-            p3.log.step("Launching GitHub login...");
+            p3.log.step("Launching Copilot login...");
             const { spawnSync } = await import("child_process");
-            const loginResult = spawnSync("gh", ["auth", "login"], {
+            const loginResult = spawnSync("copilot", ["login"], {
               stdio: "inherit"
             });
             if (loginResult.status !== 0) {
               p3.log.error("Login failed or was cancelled.");
               process.exit(1);
             }
-            p3.log.success("GitHub login successful.");
+            p3.log.success("Copilot login successful.");
           }
         }
         apiKey = "copilot";
         const modelChoice = await p3.select({
           message: "Model",
           options: [
-            { value: "gpt-4o", label: "GPT-4o", hint: "fast, recommended" },
-            { value: "gpt-4o-mini", label: "GPT-4o Mini", hint: "fastest" },
+            { value: "default", label: "Default", hint: "Copilot's default model" },
+            { value: "gpt-4o", label: "GPT-4o", hint: "fast" },
+            { value: "gpt-5.2", label: "GPT-5.2", hint: "most capable" },
             { value: "o3-mini", label: "o3-mini", hint: "reasoning" },
-            { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "via GitHub Models" },
-            { value: "meta-llama-3.1-405b-instruct", label: "Llama 3.1 405B", hint: "open source" },
-            { value: "mistral-large-2411", label: "Mistral Large", hint: "open source" },
             { value: "custom", label: "Custom model ID" }
           ],
-          initialValue: "gpt-4o"
+          initialValue: "default"
         });
         if (p3.isCancel(modelChoice)) process.exit(0);
         if (modelChoice === "custom") {
           const customModel = await p3.text({
-            message: "Model ID",
+            message: "Model ID (run copilot --help for available models)",
             placeholder: "gpt-4o",
             validate: (v) => v.length === 0 ? "Model ID is required" : void 0
           });
           if (p3.isCancel(customModel)) process.exit(0);
           defaultModel = customModel;
+        } else if (modelChoice === "default") {
+          defaultModel = "";
         } else {
           defaultModel = modelChoice;
         }