@cosmicstack/mercury-agent 0.2.7 → 0.3.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync13, existsSync as existsSync16 } from "fs";
 import { fileURLToPath } from "url";
 import { dirname as dirname3, join as join11 } from "path";
 import { Command } from "commander";
@@ -73,6 +73,10 @@ function getDefaultConfig() {
         streaming: getEnvBool("TELEGRAM_STREAMING", true)
       }
     },
+    github: {
+      username: getEnv("GITHUB_USERNAME", ""),
+      email: getEnv("GITHUB_EMAIL", "")
+    },
     memory: {
       dir: getEnv("MEMORY_DIR", join(home, "memory")),
       shortTermMaxMessages: getEnvNum("SHORT_TERM_MAX_MESSAGES", 20)
@@ -2334,8 +2338,8 @@ var PermissionManager = class {
   clearElevation() {
     this.elevatedCommands.clear();
   }
-  isElevated(tool25) {
-    if (this.elevatedCommands.has(tool25)) return true;
+  isElevated(tool30) {
+    if (this.elevatedCommands.has(tool30)) return true;
     return false;
   }
   isShellElevated() {
@@ -3281,15 +3285,19 @@ function createGitAddTool() {
 import { tool as tool22 } from "ai";
 import { z as z22 } from "zod";
 import { execSync as execSync6 } from "child_process";
+var CO_AUTHOR = "Mercury <mercury@cosmicstack.org>";
 function createGitCommitTool() {
   return tool22({
-    description: "Record changes to the repository. Creates a new commit with staged changes.",
+    description: "Record changes to the repository. Creates a new commit with staged changes. Automatically includes a Co-authored-by trailer for attribution.",
     parameters: z22.object({
       message: z22.string().describe("Commit message")
     }),
     execute: async ({ message }) => {
       try {
-        const escapedMsg = message.replace(/"/g, '\\"');
+        const fullMessage = `${message}
+
+Co-authored-by: ${CO_AUTHOR}`;
+        const escapedMsg = fullMessage.replace(/"/g, '\\"');
         const result = execSync6(`git commit -m "${escapedMsg}"`, { encoding: "utf-8", timeout: 1e4 });
         return result.trim() || "Committed successfully.";
       } catch (err) {
@@ -3336,9 +3344,302 @@ Ask the user for permission. If they approve, try again. If they say "always", u
   });
 }
 
-// src/capabilities/web/fetch-url.ts
+// src/capabilities/github/create-pr.ts
 import { tool as tool24 } from "ai";
 import { z as z24 } from "zod";
+
+// src/utils/github.ts
+var GITHUB_API = "https://api.github.com";
+var cachedToken = null;
+function setGitHubToken(token) {
+  cachedToken = token;
+}
+function getGitHubToken() {
+  if (cachedToken) return cachedToken;
+  return process.env.GITHUB_TOKEN || null;
+}
+function isGitHubConfigured() {
+  return !!getGitHubToken();
+}
+async function githubRequest(path3, options = {}) {
+  const token = getGitHubToken();
+  if (!token) {
+    throw new Error("GITHUB_TOKEN not configured. Run mercury doctor to set it up.");
+  }
+  const url = path3.startsWith("http") ? path3 : `${GITHUB_API}${path3}`;
+  const headers = {
+    "Authorization": `Bearer ${token}`,
+    "Accept": "application/vnd.github.v3+json",
+    "User-Agent": "Mercury-Agent",
+    ...options.headers
+  };
+  const fetchOptions = {
+    method: options.method || "GET",
+    headers
+  };
+  if (options.body) {
+    fetchOptions.body = JSON.stringify(options.body);
+    headers["Content-Type"] = "application/json";
+  }
+  logger.info({ method: fetchOptions.method, path: path3 }, "GitHub API request");
+  const response = await fetch(url, fetchOptions);
+  const remaining = response.headers.get("x-ratelimit-remaining");
+  if (remaining && parseInt(remaining, 10) < 100) {
+    logger.warn({ remaining }, "GitHub API rate limit running low");
+  }
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`GitHub API ${response.status}: ${body.slice(0, 500)}`);
+  }
+  if (response.status === 204) return null;
+  return response.json();
+}
+function parseRepo(remoteUrl) {
+  const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/([^.\s]+)(?:\.git)?$/);
+  if (sshMatch) return { owner: sshMatch[1], repo: sshMatch[2] };
+  const httpsMatch = remoteUrl.match(/https:\/\/github\.com\/([^/]+)\/([^.\s]+)(?:\.git)?$/);
+  if (httpsMatch) return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  return null;
+}
+async function getCurrentRepo() {
+  try {
+    const { execSync: execSync9 } = await import("child_process");
+    const remoteUrl = execSync9("git remote get-url origin", { encoding: "utf-8", timeout: 5e3 }).trim();
+    return parseRepo(remoteUrl);
+  } catch {
+    return null;
+  }
+}
+
+// src/capabilities/github/create-pr.ts
+function createCreatePrTool() {
+  return tool24({
+    description: "Create a pull request on GitHub. Requires GITHUB_TOKEN to be configured.",
+    parameters: z24.object({
+      title: z24.string().describe("PR title"),
+      body: z24.string().describe("PR description (markdown supported)").default(""),
+      head: z24.string().describe("The branch containing the changes"),
+      base: z24.string().describe("The branch to merge into").default("main"),
+      draft: z24.boolean().describe("Create as draft PR").default(false)
+    }),
+    execute: async ({ title, body, head, base, draft }) => {
+      try {
+        const repo = await getCurrentRepo();
+        if (!repo) return "Error: Could not detect GitHub repository. Make sure you are in a git repo with a GitHub remote.";
+        const result = await githubRequest(`/repos/${repo.owner}/${repo.repo}/pulls`, {
+          method: "POST",
+          body: {
+            title,
+            body,
+            head,
+            base,
+            draft
+          }
+        });
+        return `PR created: ${result.html_url}
+#${result.number}: ${result.title}
+${draft ? "(draft)" : ""} ${result.state}`;
+      } catch (err) {
+        return `Error creating PR: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/github/review-pr.ts
+import { tool as tool25 } from "ai";
+import { z as z25 } from "zod";
+function createReviewPrTool() {
+  return tool25({
+    description: "Get details of a pull request including the diff. Reviews the PR and returns the title, body, changed files, and diff. Optionally post a review comment.",
+    parameters: z25.object({
+      number: z25.number().describe("PR number"),
+      comment: z25.string().describe("Review comment to post on the PR (optional)").optional()
+    }),
+    execute: async ({ number, comment }) => {
+      try {
+        const repo = await getCurrentRepo();
+        if (!repo) return "Error: Could not detect GitHub repository.";
+        const pr = await githubRequest(`/repos/${repo.owner}/${repo.repo}/pulls/${number}`);
+        if (!pr) return `Error: PR #${number} not found.`;
+        const diff = await githubRequest(`/repos/${repo.owner}/${repo.repo}/pulls/${number}`, {
+          headers: { "Accept": "application/vnd.github.v3.diff" }
+        });
+        let summary = `PR #${pr.number}: ${pr.title}
+`;
+        summary += `Author: ${pr.user?.login}
+`;
+        summary += `State: ${pr.state} (${pr.merged ? "merged" : pr.mergeable_state || "unknown"})
+`;
+        summary += `Branch: ${pr.head.ref} \u2192 ${pr.base.ref}
+`;
+        summary += `Changed files: ${pr.changed_files} | Additions: +${pr.additions} | Deletions: -${pr.deletions}
+
+`;
+        if (pr.body) {
+          summary += `Description:
+${pr.body.slice(0, 2e3)}
+
+`;
+        }
+        if (typeof diff === "string") {
+          const diffLines = diff.split("\n");
+          const maxDiffLines = 200;
+          summary += `Diff (first ${Math.min(diffLines.length, maxDiffLines)} of ${diffLines.length} lines):
+`;
+          summary += diffLines.slice(0, maxDiffLines).join("\n");
+          if (diffLines.length > maxDiffLines) {
+            summary += `
+
+... (${diffLines.length - maxDiffLines} more lines)`;
+          }
+        } else {
+          summary += `(Diff not available in text format)`;
+        }
+        if (comment) {
+          try {
+            await githubRequest(`/repos/${repo.owner}/${repo.repo}/pulls/${number}/reviews`, {
+              method: "POST",
+              body: {
+                body: comment,
+                event: "COMMENT"
+              }
+            });
+            summary += `
+
+Review comment posted.`;
+          } catch (err) {
+            summary += `
+
+Failed to post review comment: ${err.message}`;
+          }
+        }
+        return summary;
+      } catch (err) {
+        return `Error reviewing PR: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/github/list-issues.ts
+import { tool as tool26 } from "ai";
+import { z as z26 } from "zod";
+function createListIssuesTool() {
+  return tool26({
+    description: "List open GitHub issues for the current repository. Requires GITHUB_TOKEN.",
+    parameters: z26.object({
+      state: z26.enum(["open", "closed", "all"]).describe("Filter by issue state").default("open"),
+      labels: z26.string().describe("Comma-separated label names to filter by (optional)").optional(),
+      limit: z26.number().describe("Maximum number of issues to return").default(10)
+    }),
+    execute: async ({ state, labels, limit }) => {
+      try {
+        const repo = await getCurrentRepo();
+        if (!repo) return "Error: Could not detect GitHub repository.";
+        const params = new URLSearchParams();
+        params.set("state", state);
+        params.set("per_page", String(Math.min(limit, 100)));
+        params.set("sort", "updated");
+        params.set("direction", "desc");
+        if (labels) params.set("labels", labels);
+        const issues = await githubRequest(`/repos/${repo.owner}/${repo.repo}/issues?${params}`);
+        if (!Array.isArray(issues) || issues.length === 0) {
+          return `No ${state} issues found.`;
+        }
+        const lines = issues.map((issue) => {
+          const labelStr = issue.labels?.map((l) => `[${l.name}]`).join(" ") || "";
+          return `#${issue.number} ${issue.title} ${labelStr} (${issue.state}, by ${issue.user?.login})`;
+        });
+        return `Issues in ${repo.owner}/${repo.repo} (${state}):
+${lines.join("\n")}`;
+      } catch (err) {
+        return `Error listing issues: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/github/create-issue.ts
+import { tool as tool27 } from "ai";
+import { z as z27 } from "zod";
+function createCreateIssueTool() {
+  return tool27({
+    description: "Create a new GitHub issue in the current repository. Requires GITHUB_TOKEN.",
+    parameters: z27.object({
+      title: z27.string().describe("Issue title"),
+      body: z27.string().describe("Issue description (markdown supported)").default(""),
+      labels: z27.array(z27.string()).describe("Label names to apply").optional()
+    }),
+    execute: async ({ title, body, labels }) => {
+      try {
+        const repo = await getCurrentRepo();
+        if (!repo) return "Error: Could not detect GitHub repository.";
+        const payload = { title, body };
+        if (labels && labels.length > 0) payload.labels = labels;
+        const result = await githubRequest(`/repos/${repo.owner}/${repo.repo}/issues`, {
+          method: "POST",
+          body: payload
+        });
+        return `Issue created: ${result.html_url}
+#${result.number}: ${result.title}`;
+      } catch (err) {
+        return `Error creating issue: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/github/github-api.ts
+import { tool as tool28 } from "ai";
+import { z as z28 } from "zod";
+function createGithubApiTool(permissions) {
+  return tool28({
+    description: "Make a raw request to the GitHub API. Use this for any GitHub operation not covered by other tools. GET requests are auto-approved; write operations (POST, PUT, PATCH, DELETE) require approval.",
+    parameters: z28.object({
+      path: z28.string().describe("API path (e.g., /repos/owner/repo/releases)"),
+      method: z28.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).describe("HTTP method").default("GET"),
+      body: z28.string().describe("JSON body for write requests (as a JSON string)").optional()
+    }),
+    execute: async ({ path: path3, method, body }) => {
+      const isWrite = ["POST", "PUT", "PATCH", "DELETE"].includes(method);
+      if (isWrite) {
+        const check = await permissions.checkShellCommand(`github-api ${method} ${path3}`);
+        if (!check.allowed) {
+          if (check.needsApproval) {
+            return `This GitHub API write operation requires approval: ${method} ${path3}
+
+Tell the user what this does and ask for confirmation. If approved, try again.`;
+          }
+          return `Error: ${check.reason}`;
+        }
+      }
+      try {
+        let parsedBody;
+        if (body) {
+          try {
+            parsedBody = JSON.parse(body);
+          } catch {
+            return "Error: body must be valid JSON.";
+          }
+        }
+        const result = await githubRequest(path3, {
+          method,
+          body: parsedBody
+        });
+        if (result === null) return "Request completed (204 No Content).";
+        if (typeof result === "string") return result;
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        return `Error: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/web/fetch-url.ts
+import { tool as tool29 } from "ai";
+import { z as z29 } from "zod";
 var MAX_CONTENT_LENGTH = 15e3;
 function stripHtml(html) {
   let text = html;
@@ -3371,11 +3672,11 @@ function stripHtml(html) {
   return text;
 }
 function createFetchUrlTool() {
-  return tool24({
+  return tool29({
     description: "Fetch a URL and return its content as text. Strips HTML to readable markdown-like format. Useful for reading documentation, APIs, or web pages.",
-    parameters: z24.object({
-      url: z24.string().describe("The URL to fetch"),
-      format: z24.enum(["text", "markdown"]).optional().describe("Output format (default: markdown)")
+    parameters: z29.object({
+      url: z29.string().describe("The URL to fetch"),
+      format: z29.enum(["text", "markdown"]).optional().describe("Output format (default: markdown)")
     }),
     execute: async ({ url, format }) => {
       const outputFormat = format ?? "markdown";
@@ -3497,6 +3798,14 @@ var CapabilityRegistry = class {
       this.tools.git_push = createGitPushTool(this.permissions);
       logger.info("Git tools registered");
     }
+    if (isGitHubConfigured()) {
+      this.tools.create_pr = createCreatePrTool();
+      this.tools.review_pr = createReviewPrTool();
+      this.tools.list_issues = createListIssuesTool();
+      this.tools.create_issue = createCreateIssueTool();
+      this.tools.github_api = createGithubApiTool(this.permissions);
+      logger.info("GitHub tools registered");
+    }
     this.tools.fetch_url = createFetchUrlTool();
     logger.info("Web fetch tool registered");
   }
@@ -4360,6 +4669,17 @@ function maskKey(key) {
   if (key.length <= 8) return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
   return key.slice(0, 4) + "\u2022\u2022\u2022\u2022" + key.slice(-4);
 }
+function appendToEnv(key, value) {
+  const envPath = join11(getMercuryHome(), ".env");
+  let envContent = "";
+  if (existsSync16(envPath)) {
+    envContent = readFileSync12(envPath, "utf-8");
+  }
+  const lines = envContent.split("\n").filter((l) => !l.startsWith(`${key}=`) && l.trim() !== "");
+  lines.push(`${key}=${value}`);
+  writeFileSync13(envPath, lines.join("\n") + "\n", "utf-8");
+  process.env[key] = value;
+}
 async function configure(existingConfig) {
   const isReconfig = !!existingConfig;
   const config = existingConfig ?? loadConfig();
@@ -4458,6 +4778,23 @@ async function configure(existingConfig) {
   }
   hr();
   console.log("");
+  console.log(chalk6.bold.white("  GitHub (optional)"));
+  console.log(chalk6.dim("  Connect Mercury to GitHub for PRs, issues, and co-authored commits."));
+  console.log(chalk6.dim("  Leave empty to skip. You can add it later with mercury doctor."));
+  console.log("");
+  const ghUserCurrent = isReconfig && config.github.username ? ` [${config.github.username}]` : "";
+  const ghUsername = await ask(chalk6.white(`  GitHub username${ghUserCurrent}: `));
+  if (ghUsername) config.github.username = ghUsername;
+  const ghEmailCurrent = isReconfig && config.github.email ? ` [${config.github.email}]` : "";
+  const ghEmail = await ask(chalk6.white(`  GitHub email${ghEmailCurrent}: `));
+  if (ghEmail) config.github.email = ghEmail;
+  const ghTokenCurrent = process.env.GITHUB_TOKEN ? ` [${maskKey(process.env.GITHUB_TOKEN)}]` : "";
+  const ghToken = await ask(chalk6.white(`  GitHub PAT (repo scope)${ghTokenCurrent}: `));
+  if (ghToken) {
+    appendToEnv("GITHUB_TOKEN", ghToken);
+  }
+  hr();
+  console.log("");
   console.log(chalk6.bold.white("  Token Budget"));
   console.log("");
   const budgetPrompt = isReconfig ? chalk6.white(`  Daily token budget [${config.tokens.dailyBudget.toLocaleString()}]: `) : chalk6.white(`  Daily token budget [${config.tokens.dailyBudget.toLocaleString()}]: `);
@@ -4558,6 +4895,9 @@ async function runAgent(isDaemon = false) {
       await msg.sendFile(filePath);
     }
   });
+  if (process.env.GITHUB_TOKEN) {
+    setGitHubToken(process.env.GITHUB_TOKEN);
+  }
   capabilities.registerAll();
   const agent = new Agent(
     config,