@aman_asmuei/aman-agent 0.21.0 → 0.21.1

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)}
+
+`;
+    }
+    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 token;
-  } catch {
-    throw new Error(
-      "Failed to get GitHub token. Run: gh auth login"
-    );
   }
+  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);
+          }
+        });
+      });
     }
   };
 }
@@ -3914,7 +4023,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.21.1" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc5.green("Up to date")} \u2014 v${local}` };
     }
@@ -6369,7 +6478,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.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) {
@@ -6491,68 +6600,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;
         }