@aman_asmuei/aman-agent 0.18.0 → 0.21.1

package/dist/index.js

@@ -726,6 +726,474 @@ function createOllamaClient(model, baseURL) {
   };
 }
 
+// src/llm/claude-code.ts
+import { spawn, execFileSync } from "child_process";
+function isClaudeCliInstalled() {
+  try {
+    execFileSync("which", ["claude"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractText(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 formatConversation(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)}
+
+`;
+    }
+    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 = extractText(msg.content);
+      parts.push(`[${role}]: ${text3}`);
+    }
+    parts.push("</conversation_history>\n");
+  }
+  const lastMsg = messages[messages.length - 1];
+  if (lastMsg) {
+    parts.push(extractText(lastMsg.content));
+  }
+  return { prompt: parts.join("\n"), systemPrompt: fullSystem };
+}
+function parseToolUses(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 createClaudeCodeClient(model) {
+  return {
+    async chat(systemPrompt, messages, onChunk, tools, options) {
+      const { prompt, systemPrompt: fullSystem } = formatConversation(
+        systemPrompt,
+        messages,
+        tools
+      );
+      return new Promise((resolve, reject) => {
+        const args = [
+          "--print",
+          "--output-format",
+          "stream-json",
+          "--system-prompt",
+          fullSystem
+        ];
+        if (model) {
+          args.push("--model", model);
+        }
+        if (options?.maxOutputTokens) {
+          args.push("--max-tokens", String(options.maxOutputTokens));
+        }
+        const proc = spawn("claude", args, {
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        let fullText = "";
+        let buffer = "";
+        let stderrOutput = "";
+        proc.stdin.write(prompt);
+        proc.stdin.end();
+        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") {
+                if (event.subtype === "text" && event.content) {
+                  fullText += event.content;
+                  onChunk({ type: "text", text: event.content });
+                }
+              } 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.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 });
+                  }
+                }
+              }
+            } catch {
+              if (line.trim()) {
+                fullText += line;
+                onChunk({ type: "text", text: line });
+              }
+            }
+          }
+        });
+        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.subtype === "text" && event.content) {
+                fullText += event.content;
+                onChunk({ type: "text", text: event.content });
+              }
+            } catch {
+              if (buffer.trim()) {
+                fullText += buffer;
+                onChunk({ type: "text", text: buffer });
+              }
+            }
+          }
+          onChunk({ type: "done" });
+          if (code !== 0 && !fullText) {
+            reject(
+              new Error(
+                `Claude CLI exited with code ${code}${stderrOutput ? `: ${stderrOutput.trim()}` : ""}`
+              )
+            );
+            return;
+          }
+          const hasTools = tools && tools.length > 0;
+          if (hasTools) {
+            const toolUses = parseToolUses(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(
+                "Claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code"
+              )
+            );
+          } else {
+            reject(err);
+          }
+        });
+      });
+    }
+  };
+}
+
+// src/llm/copilot.ts
+import { spawn as spawn2, execFileSync as execFileSync2 } from "child_process";
+function isCopilotCliInstalled() {
+  try {
+    execFileSync2("which", ["copilot"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isCopilotCliAuthenticated() {
+  try {
+    const result = execFileSync2("copilot", ["--version"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3
+    });
+    return result.toString().trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+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)}
+
+`;
+    }
+    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 { 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 = "";
+        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 });
+              }
+            }
+          }
+        });
+        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 });
+              }
+            }
+          }
+          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);
+          }
+        });
+      });
+    }
+  };
+}
+
 // src/mcp/client.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -931,7 +1399,7 @@ import logUpdate from "log-update";
 import fs12 from "fs";
 import path12 from "path";
 import os11 from "os";
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 import pc5 from "picocolors";
 
 // src/layers/parsers.ts
@@ -3487,6 +3955,7 @@ function handleHelp() {
       `  ${pc5.cyan("/profile me")}   View your profile`,
       `  ${pc5.cyan("/profile edit")} Edit your profile`,
       `  ${pc5.cyan("/profile")}      List agent profiles`,
+      `  ${pc5.cyan("/showcase")}     Browse & switch companion templates`,
       `  ${pc5.cyan("/delegate")}     Delegate tasks to sub-agents`,
       `  ${pc5.cyan("/team")}         Manage agent teams`,
       `  ${pc5.cyan("/update")}       Check for updates`,
@@ -3553,8 +4022,8 @@ function handleReset(action) {
 }
 function handleUpdate() {
   try {
-    const current = execFileSync("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.18.0" : "unknown";
+    const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
+    const local = true ? "0.21.1" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc5.green("Up to date")} \u2014 v${local}` };
     }
@@ -4123,6 +4592,103 @@ async function handleReminderCommand(action, args) {
   }
   return { handled: true, output: pc5.yellow(`Unknown action: /reminder ${action}. Try /reminder --help`) };
 }
+function handleShowcaseCommand(action, args) {
+  const showcases = loadShowcaseManifest();
+  if (showcases.length === 0) {
+    return {
+      handled: true,
+      output: pc5.dim("No showcase templates found.") + `
+
+  Install aman-showcase to get 13 pre-built companion personalities:
+  ${pc5.bold("npm install -g @aman_asmuei/aman-showcase")}
+  Or place it as a sibling directory to aman-agent.`
+    };
+  }
+  const corePath = path12.join(os11.homedir(), ".acore", "core.md");
+  let currentShowcase = null;
+  if (fs12.existsSync(corePath)) {
+    const content = fs12.readFileSync(corePath, "utf-8");
+    const nameMatch = content.match(/^# (.+)/m);
+    if (nameMatch) {
+      const coreName = nameMatch[1].trim().toLowerCase();
+      const match = showcases.find((s) => coreName.includes(s.name) || coreName.includes(s.title.split("\u2014")[0].trim().toLowerCase()));
+      if (match) currentShowcase = match.name;
+    }
+  }
+  if (!action || action === "list") {
+    const lines = showcases.map((s) => {
+      const active = s.name === currentShowcase ? pc5.green(" \u2190 active") : "";
+      const langBadge = s.language === "ms" ? " [BM]" : s.language === "en+ms" ? " [EN/BM]" : "";
+      return `  ${pc5.bold(s.name.padEnd(12))} ${s.title}${langBadge}${active}`;
+    });
+    const currentLine = currentShowcase ? `
+Current: ${pc5.bold(currentShowcase)}
+` : `
+No showcase active (using default personality)
+`;
+    return {
+      handled: true,
+      output: `Showcase templates (${showcases.length}):
+
+${lines.join("\n")}
+${currentLine}
+${pc5.dim("Switch with: /showcase install <name>")}`
+    };
+  }
+  if (action === "install" || action === "switch" || action === "use") {
+    const name = args[0];
+    if (!name) {
+      return { handled: true, output: pc5.yellow("Usage: /showcase install <name>\n\nRun /showcase list to see available templates.") };
+    }
+    const entry = showcases.find((s) => s.name === name);
+    if (!entry) {
+      return { handled: true, output: pc5.red(`Showcase not found: ${name}`) + `
+
+Available: ${showcases.map((s) => s.name).join(", ")}` };
+    }
+    if (name === currentShowcase) {
+      return { handled: true, output: pc5.dim(`${entry.title} is already active.`) };
+    }
+    try {
+      const result = installShowcaseTemplate(name);
+      const lines = [pc5.green(`Installed ${pc5.bold(entry.title)}`)];
+      for (const f of result.installed) {
+        lines.push(pc5.dim(`  ${f}`));
+      }
+      if (result.backed_up.length > 0) {
+        lines.push(pc5.dim(`
+  Backed up ${result.backed_up.length} existing file(s) (.bak)`));
+      }
+      lines.push("");
+      lines.push(pc5.yellow("Restart aman-agent to use the new personality."));
+      lines.push(pc5.dim("Your user profile (/profile me) is unchanged \u2014 only the AI personality switched."));
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Failed to install: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "current") {
+    if (currentShowcase) {
+      const entry = showcases.find((s) => s.name === currentShowcase);
+      return { handled: true, output: `Active showcase: ${pc5.bold(entry?.title || currentShowcase)}
+${pc5.dim(entry?.description || "")}` };
+    }
+    return { handled: true, output: pc5.dim("No showcase active \u2014 using default personality.") + `
+${pc5.dim("Install one with: /showcase install <name>")}` };
+  }
+  if (action === "help") {
+    return { handled: true, output: `Showcase commands:
+
+  /showcase              List all available templates
+  /showcase install <n>  Install/switch to a template
+  /showcase current      Show active template
+
+${pc5.dim("Showcase templates replace your AI's personality, workflows, rules, and skills.")}
+${pc5.dim("Your user profile (/profile me) stays unchanged \u2014 only the AI personality switches.")}
+${pc5.dim("Existing files are backed up (.bak) before overwriting.")}` };
+  }
+  return { handled: true, output: pc5.yellow(`Unknown action: /showcase ${action}. Try /showcase help`) };
+}
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "quit",
   "exit",
@@ -4151,7 +4717,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "plan",
   "profile",
   "delegate",
-  "team"
+  "team",
+  "showcase"
 ]);
 async function handleCommand(input, ctx) {
   const trimmed = input.trim();
@@ -4208,6 +4775,8 @@ async function handleCommand(input, ctx) {
       return handleTeamCommand(action, args, ctx);
     case "reminder":
       return handleReminderCommand(action, args);
+    case "showcase":
+      return handleShowcaseCommand(action, args);
     case "update":
     case "upgrade":
       return handleUpdate();
@@ -5909,7 +6478,7 @@ function bootstrapEcosystem() {
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.18.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.21.1").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
   p3.intro(pc8.bold("aman agent") + pc8.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -5926,14 +6495,19 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
         message: "LLM provider",
         options: [
           {
-            value: "anthropic",
+            value: "claude-code",
             label: "Claude (Anthropic)",
             hint: "recommended"
           },
+          {
+            value: "copilot",
+            label: "GitHub Copilot",
+            hint: "uses GitHub Models"
+          },
           { value: "openai", label: "GPT (OpenAI)" },
           { value: "ollama", label: "Ollama (local)", hint: "free, runs offline" }
         ],
-        initialValue: "anthropic"
+        initialValue: "claude-code"
       });
       if (p3.isCancel(provider)) process.exit(0);
       let apiKey = "";
@@ -5947,20 +6521,58 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
         });
         if (p3.isCancel(modelInput)) process.exit(0);
         defaultModel = modelInput || "llama3.2";
-      } else if (provider === "anthropic") {
-        p3.log.info("Get your API key from: https://console.anthropic.com/settings/keys");
-        p3.log.info(pc8.dim("Note: API access is separate from Claude Pro subscription. You need API credits."));
-        apiKey = await p3.text({
-          message: "API key (starts with sk-ant-)",
-          validate: (v) => v.length === 0 ? "API key is required" : void 0
+      } else if (provider === "claude-code") {
+        p3.note(
+          [
+            `${pc8.bold("Claude Plans:")}`,
+            "",
+            `  ${pc8.cyan("Free")}          $0/mo       Basic access`,
+            `  ${pc8.cyan("Pro")}           $20/mo      Full models + Claude Code`,
+            `  ${pc8.cyan("Max 5x")}        $100/mo     5\xD7 usage + Claude Code`,
+            `  ${pc8.cyan("Max 20x")}       $200/mo     20\xD7 usage + Opus 4.6 + 1M context`,
+            `  ${pc8.cyan("Team")}          $25+/seat   Collaborative workspace`,
+            `  ${pc8.cyan("Enterprise")}    Custom      SSO, admin, dedicated support`,
+            "",
+            `${pc8.dim("Authentication is handled by Claude Code CLI.")}`,
+            `${pc8.dim("Supports: subscription, API billing, Bedrock, Vertex AI.")}`
+          ].join("\n"),
+          "Claude Plans"
+        );
+        if (!isClaudeCliInstalled()) {
+          p3.log.error("Claude Code CLI is not installed.");
+          p3.log.info("Install it with:");
+          p3.log.step(pc8.bold("npm install -g @anthropic-ai/claude-code"));
+          p3.log.info(pc8.dim("Then re-run aman-agent to continue setup."));
+          process.exit(1);
+        }
+        p3.log.success("Claude Code CLI detected.");
+        const authAction = await p3.select({
+          message: "Authentication",
+          options: [
+            { value: "logged-in", label: "Already logged in to Claude Code" },
+            { value: "login", label: "Log in now", hint: "runs: claude login" }
+          ]
         });
-        if (p3.isCancel(apiKey)) process.exit(0);
+        if (p3.isCancel(authAction)) process.exit(0);
+        if (authAction === "login") {
+          p3.log.step("Launching Claude Code login...");
+          const { spawnSync } = await import("child_process");
+          const loginResult = spawnSync("claude", ["login"], {
+            stdio: "inherit"
+          });
+          if (loginResult.status !== 0) {
+            p3.log.error("Login failed or was cancelled. Please try again.");
+            process.exit(1);
+          }
+          p3.log.success("Login successful.");
+        }
+        apiKey = "claude-code";
         const modelChoice = await p3.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: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5", hint: "fastest" },
             { value: "custom", label: "Custom model ID" }
           ],
           initialValue: "claude-sonnet-4-6"
@@ -5977,6 +6589,82 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
         } else {
           defaultModel = modelChoice;
         }
+      } else if (provider === "copilot") {
+        p3.note(
+          [
+            `${pc8.bold("GitHub Copilot Plans:")}`,
+            "",
+            `  ${pc8.cyan("Free")}          $0/mo       2,000 code completions + 50 chat msgs`,
+            `  ${pc8.cyan("Pro")}           $10/mo      Unlimited completions + chat`,
+            `  ${pc8.cyan("Pro+")}          $39/mo      Unlimited + Opus/o1 + agent mode`,
+            `  ${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 Copilot CLI.")}`,
+            `${pc8.dim("Subscribe at: https://github.com/features/copilot")}`
+          ].join("\n"),
+          "Copilot Plans"
+        );
+        if (!isCopilotCliInstalled()) {
+          p3.log.error("Copilot CLI is not installed.");
+          p3.log.info("Install it from:");
+          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("Copilot CLI detected.");
+        const copilotAuth = isCopilotCliAuthenticated();
+        if (copilotAuth) {
+          p3.log.success("Copilot authentication found.");
+        } else {
+          p3.log.warn("Not logged in to Copilot.");
+          const authAction = await p3.select({
+            message: "Authentication",
+            options: [
+              { 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 Copilot login...");
+            const { spawnSync } = await import("child_process");
+            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("Copilot login successful.");
+          }
+        }
+        apiKey = "copilot";
+        const modelChoice = await p3.select({
+          message: "Model",
+          options: [
+            { 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: "custom", label: "Custom model ID" }
+          ],
+          initialValue: "default"
+        });
+        if (p3.isCancel(modelChoice)) process.exit(0);
+        if (modelChoice === "custom") {
+          const customModel = await p3.text({
+            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;
+        }
       } else {
         apiKey = await p3.text({
           message: "API key",
@@ -6093,7 +6781,11 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
     input_schema: t.input_schema
   }));
   let client;
-  if (config.provider === "anthropic") {
+  if (config.provider === "claude-code") {
+    client = createClaudeCodeClient(model);
+  } else if (config.provider === "copilot") {
+    client = createCopilotClient(model);
+  } else if (config.provider === "anthropic") {
     client = createAnthropicClient(config.apiKey, model);
   } else if (config.provider === "ollama") {
     client = createOllamaClient(model);