aether-code 0.37.0 → 0.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-code",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "Uncensored AI coding agent for your terminal — Claude Code alternative with MCP support. Reads code, writes files, runs commands. Drives IDA Pro, Roblox Studio, Wireshark, Blender, and any MCP server. No refusal layer.",
   "homepage": "https://trynoguard.com",
   "repository": {

package/src/render.js

@@ -88,6 +88,13 @@ export function toolLabel(name, args) {
     case "web_fetch":    return `${verb("fetch")}  ${arg(a.url)}`;
     case "todo_write":   return ""; // its Plan box is the label
     case "ask_user":     return ""; // the interactive menu is its display
+    case "git_status":   return `${verb("git")}    ${arg("status")}`;
+    case "git_diff":     return `${verb("git")}    ${arg("diff" + (a.staged ? " --staged" : "") + (a.base ? ` ${a.base}...${a.head || "HEAD"}` : ""))}`;
+    case "git_log":      return `${verb("git")}    ${arg("log" + (a.file ? ` -- ${a.file}` : "") + (a.branch ? ` ${a.branch}` : ""))}`;
+    case "git_commit":   return `${verb("git")}    ${arg(`commit "${ellip(a.message || "", 50)}"`)}`
+    case "git_branch":   return `${verb("git")}    ${arg(`branch ${a.name}`)}`;
+    case "git_push":     return `${verb("git")}    ${arg("push" + (a.force ? " --force" : ""))}`;
+    case "git_create_pr": return `${verb("git")}    ${arg(`pr "${ellip(a.title || "", 50)}"`)}`
     default:             return `${verb(name)} ${arg(JSON.stringify(a))}`;
   }
 }
@@ -142,6 +149,32 @@ export function toolSummary(name, result) {
   }
   if (name === "todo_write") return ""; // the Plan is its own feedback
   if (name === "ask_user") return ""; // the menu already showed the answer
+  if (name === "git_commit" || name === "git_push" || name === "git_create_pr") {
+    return `  ${branch} ${c.gray(ellip(firstLine, 100))}`;
+  }
+  if (name === "git_status") {
+    try {
+      const s = JSON.parse(out);
+      if (s.clean) return `  ${branch} ${c.gray("clean")}`;
+      const parts = [];
+      if (s.staged?.length) parts.push(`${s.staged.length} staged`);
+      if (s.unstaged?.length) parts.push(`${s.unstaged.length} modified`);
+      if (s.untracked?.length) parts.push(`${s.untracked.length} untracked`);
+      return `  ${branch} ${c.gray(parts.join(", "))}`;
+    } catch { /* fall through */ }
+  }
+  if (name === "git_diff") {
+    if (out === "(no changes)") return `  ${branch} ${c.gray("no changes")}`;
+    const diffLines = out.split("\n").length;
+    return `  ${branch} ${c.gray(`${diffLines} lines of diff`)}`;
+  }
+  if (name === "git_log") {
+    const logLines = out.trim().split("\n").filter((l) => l.trim()).length;
+    return `  ${branch} ${c.gray(`${logLines} lines`)}`;
+  }
+  if (name === "git_branch") {
+    return `  ${branch} ${c.gray(ellip(firstLine, 100))}`;
+  }
   if (name === "write_file" || name === "edit_file") {
     // Handler already printed the diff; echo its short status line.
     return `  ${branch} ${c.gray(ellip(firstLine, 100))}`;

package/src/tools.js

@@ -223,6 +223,125 @@ export const TOOL_DEFINITIONS = [
       },
     },
   },
+  /* ─────────────────────── Git tools ─────────────────────── */
+  {
+    type: "function",
+    function: {
+      name: "git_status",
+      description:
+        "Show the working tree status — staged, unstaged, and untracked files. Auto-executes (read-only). Use this before committing to see what's changed.",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "git_diff",
+      description:
+        "Show a unified diff of changes. By default shows unstaged changes. Set staged=true for staged changes, or pass base/head for branch comparisons (e.g. base='main' head='HEAD'). Optionally limit to specific file(s).",
+      parameters: {
+        type: "object",
+        properties: {
+          staged: { type: "boolean", description: "Show staged (--cached) diff instead of unstaged. Default: false." },
+          base: { type: "string", description: "Base ref for comparison (e.g. 'main', 'HEAD~3'). When set, shows diff between base and head." },
+          head: { type: "string", description: "Head ref for comparison. Default: 'HEAD' when base is set." },
+          files: {
+            type: "array",
+            description: "Limit diff to these file paths.",
+            items: { type: "string" },
+          },
+        },
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "git_log",
+      description:
+        "Show recent commit history with hash, author, date, and message. Defaults to 15 commits. Use this to understand what's been done recently, find commit hashes, or check the commit style before committing.",
+      parameters: {
+        type: "object",
+        properties: {
+          count: { type: "number", description: "Number of commits to show (1-50). Default: 15." },
+          oneline: { type: "boolean", description: "Compact one-line format. Default: false." },
+          file: { type: "string", description: "Show only commits that touched this file." },
+          branch: { type: "string", description: "Show commits on this branch instead of HEAD." },
+        },
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "git_commit",
+      description:
+        "Stage files and create a commit. If no files are specified, stages all modified/new files (git add -A). The user will see what's being committed and confirm. Use git_status first to see what's changed, and git_log to match the commit message style.",
+      parameters: {
+        type: "object",
+        properties: {
+          message: { type: "string", description: "Commit message. Be concise — focus on WHY, not WHAT." },
+          files: {
+            type: "array",
+            description: "Specific files to stage. If omitted, stages everything (git add -A).",
+            items: { type: "string" },
+          },
+        },
+        required: ["message"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "git_branch",
+      description:
+        "Create and/or switch to a branch. If the branch exists, switches to it. If it doesn't, creates it from the current HEAD (or from 'base' if specified) and switches to it.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Branch name to create or switch to." },
+          base: { type: "string", description: "Create the branch from this ref instead of HEAD." },
+        },
+        required: ["name"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "git_push",
+      description:
+        "Push the current branch to the remote. Sets upstream tracking (-u origin) on first push. The user will confirm before pushing.",
+      parameters: {
+        type: "object",
+        properties: {
+          force: { type: "boolean", description: "Force push (--force-with-lease). Use only when explicitly asked. Default: false." },
+        },
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "git_create_pr",
+      description:
+        "Create a GitHub pull request using the `gh` CLI. Requires `gh` to be installed and authenticated. Pushes the branch first if needed. The user will confirm before creating.",
+      parameters: {
+        type: "object",
+        properties: {
+          title: { type: "string", description: "PR title. Keep under 72 chars." },
+          body: { type: "string", description: "PR body/description. Markdown supported." },
+          base: { type: "string", description: "Target branch to merge into. Default: repo default (usually main)." },
+          draft: { type: "boolean", description: "Create as a draft PR. Default: false." },
+        },
+        required: ["title", "body"],
+      },
+    },
+  },
 ];
 
 /* ─────────────────────── Argument validation ─────────────────────── */
@@ -410,6 +529,13 @@ export async function executeTool(call, opts) {
     web_fetch: () => webFetch(args, opts),
     todo_write: () => todoWrite(args, opts),
     ask_user: () => askUser(args, opts),
+    git_status: () => gitStatus(args, opts),
+    git_diff: () => gitDiff(args, opts),
+    git_log: () => gitLog(args, opts),
+    git_commit: () => gitCommit(args, opts),
+    git_branch: () => gitBranch(args, opts),
+    git_push: () => gitPush(args, opts),
+    git_create_pr: () => gitCreatePr(args, opts),
   };
   const fn = handlers[name];
   if (!fn) {
@@ -859,6 +985,226 @@ async function runShell(args, opts) {
   });
 }
 
+/* ─────────────────────── Git tools ─────────────────────── */
+
+function runGit(gitArgs, cwd, timeoutMs = 30_000) {
+  return new Promise((resolve) => {
+    const child = spawn("git", gitArgs, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    const timer = setTimeout(() => { killed = true; child.kill("SIGTERM"); }, timeoutMs);
+    child.stdout.on("data", (d) => { stdout += d.toString(); });
+    child.stderr.on("data", (d) => { stderr += d.toString(); });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const truncate = (t) => (t.length > 30_000 ? t.slice(0, 30_000) + "\n…(truncated)" : t);
+      resolve({ code, killed, stdout: truncate(stdout), stderr: truncate(stderr) });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({ code: 1, killed: false, stdout: "", stderr: `git spawn error: ${err.message}` });
+    });
+  });
+}
+
+async function gitStatus(_args, opts) {
+  const r = await runGit(["status", "--short", "--branch", "-u"], opts.cwd);
+  if (r.code !== 0) return { ok: false, output: r.stderr || "git status failed" };
+  const lines = r.stdout.trim().split("\n");
+  const branchLine = lines[0] || "";
+  const files = lines.slice(1).filter((l) => l.trim());
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  for (const line of files) {
+    const x = line[0];
+    const y = line[1];
+    const name = line.slice(3);
+    if (x === "?") { untracked.push(name); continue; }
+    if (x !== " " && x !== "?") staged.push({ status: x, file: name });
+    if (y !== " " && y !== "?") unstaged.push({ status: y, file: name });
+  }
+  const result = {
+    branch: branchLine.replace(/^## /, ""),
+    staged,
+    unstaged,
+    untracked,
+    clean: staged.length === 0 && unstaged.length === 0 && untracked.length === 0,
+  };
+  return { ok: true, output: JSON.stringify(result, null, 2) };
+}
+
+async function gitDiff(args, opts) {
+  const gitArgs = ["diff", "--stat", "--patch"];
+  if (args.staged) gitArgs.push("--cached");
+  if (args.base) {
+    const head = args.head || "HEAD";
+    gitArgs.length = 0;
+    gitArgs.push("diff", args.base + "..." + head, "--stat", "--patch");
+  }
+  if (Array.isArray(args.files) && args.files.length > 0) {
+    gitArgs.push("--");
+    for (const f of args.files) gitArgs.push(f);
+  }
+  const r = await runGit(gitArgs, opts.cwd, 60_000);
+  if (r.code !== 0) return { ok: false, output: r.stderr || "git diff failed" };
+  if (!r.stdout.trim()) return { ok: true, output: "(no changes)" };
+  return { ok: true, output: r.stdout };
+}
+
+async function gitLog(args, opts) {
+  const count = Math.min(50, Math.max(1, args.count ?? 15));
+  const gitArgs = ["log", `-${count}`];
+  if (args.oneline) {
+    gitArgs.push("--oneline");
+  } else {
+    gitArgs.push("--format=%h %an (%ar)%n  %s%n");
+  }
+  if (args.branch) gitArgs.push(args.branch);
+  if (args.file) { gitArgs.push("--"); gitArgs.push(args.file); }
+  const r = await runGit(gitArgs, opts.cwd);
+  if (r.code !== 0) return { ok: false, output: r.stderr || "git log failed" };
+  if (!r.stdout.trim()) return { ok: true, output: "(no commits)" };
+  return { ok: true, output: r.stdout };
+}
+
+async function gitCommit(args, opts) {
+  if (typeof args.message !== "string" || !args.message.trim()) {
+    return { ok: false, output: "commit message is required" };
+  }
+  // Stage files
+  const filesToStage = Array.isArray(args.files) && args.files.length > 0 ? args.files : null;
+  if (filesToStage) {
+    const addR = await runGit(["add", "--", ...filesToStage], opts.cwd);
+    if (addR.code !== 0) return { ok: false, output: `git add failed: ${addR.stderr}` };
+  } else {
+    const addR = await runGit(["add", "-A"], opts.cwd);
+    if (addR.code !== 0) return { ok: false, output: `git add -A failed: ${addR.stderr}` };
+  }
+  // Show what's staged
+  const staged = await runGit(["diff", "--cached", "--stat"], opts.cwd);
+  if (!staged.stdout.trim()) {
+    return { ok: false, output: "Nothing to commit — no staged changes after git add." };
+  }
+  console.log(c.dim(staged.stdout));
+  console.log(c.cyan("commit message: ") + c.bold(args.message));
+  const approved = await confirm(c.yellow("Create this commit?"), opts.autoYes);
+  if (!approved) {
+    await runGit(["reset", "HEAD"], opts.cwd);
+    return { ok: false, output: "User declined the commit. Staged changes have been unstaged." };
+  }
+  const commitR = await runGit(["commit", "-m", args.message], opts.cwd);
+  if (commitR.code !== 0) return { ok: false, output: `git commit failed: ${commitR.stderr}` };
+  // Get the commit hash for confirmation
+  const hashR = await runGit(["rev-parse", "--short", "HEAD"], opts.cwd);
+  const hash = hashR.stdout.trim();
+  return { ok: true, output: `Committed ${hash}: ${args.message}\n${commitR.stdout}` };
+}
+
+async function gitBranch(args, opts) {
+  if (typeof args.name !== "string" || !args.name.trim()) {
+    return { ok: false, output: "branch name is required" };
+  }
+  // Check if branch exists
+  const checkR = await runGit(["rev-parse", "--verify", args.name], opts.cwd);
+  if (checkR.code === 0) {
+    // Branch exists, switch to it
+    const switchR = await runGit(["checkout", args.name], opts.cwd);
+    if (switchR.code !== 0) return { ok: false, output: `git checkout failed: ${switchR.stderr}` };
+    return { ok: true, output: `Switched to existing branch '${args.name}'` };
+  }
+  // Create new branch
+  const createArgs = ["checkout", "-b", args.name];
+  if (args.base) createArgs.push(args.base);
+  const createR = await runGit(createArgs, opts.cwd);
+  if (createR.code !== 0) return { ok: false, output: `git checkout -b failed: ${createR.stderr}` };
+  return { ok: true, output: `Created and switched to new branch '${args.name}'${args.base ? ` from ${args.base}` : ""}` };
+}
+
+async function gitPush(args, opts) {
+  // Get current branch name
+  const branchR = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], opts.cwd);
+  if (branchR.code !== 0) return { ok: false, output: `Cannot determine current branch: ${branchR.stderr}` };
+  const branch = branchR.stdout.trim();
+  if (!branch || branch === "HEAD") {
+    return { ok: false, output: "Cannot push — HEAD is detached. Checkout a branch first." };
+  }
+  const pushArgs = ["push", "-u", "origin", branch];
+  if (args.force) pushArgs.splice(1, 0, "--force-with-lease");
+  console.log(c.yellow("$ ") + c.bold(`git ${pushArgs.join(" ")}`));
+  const approved = await confirm(c.yellow(`Push '${branch}' to origin?`), opts.autoYes);
+  if (!approved) return { ok: false, output: "User declined the push." };
+  const r = await runGit(pushArgs, opts.cwd, 60_000);
+  if (r.code !== 0) return { ok: false, output: `git push failed: ${r.stderr}` };
+  return { ok: true, output: `Pushed '${branch}' to origin.\n${r.stderr}${r.stdout}`.trim() };
+}
+
+async function gitCreatePr(args, opts) {
+  if (typeof args.title !== "string" || !args.title.trim()) {
+    return { ok: false, output: "PR title is required" };
+  }
+  if (typeof args.body !== "string") {
+    return { ok: false, output: "PR body is required" };
+  }
+  // Check if gh CLI is available
+  const ghCheck = await runGit(["--version"], opts.cwd);
+  void ghCheck;
+  const ghVerify = new Promise((resolve) => {
+    const child = spawn("gh", ["--version"], { cwd: opts.cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    child.stdout.on("data", (d) => { out += d.toString(); });
+    child.on("close", (code) => resolve({ code, stdout: out }));
+    child.on("error", () => resolve({ code: 1, stdout: "" }));
+  });
+  const ghResult = await ghVerify;
+  if (ghResult.code !== 0) {
+    return { ok: false, output: "GitHub CLI (gh) is not installed or not in PATH. Install it: https://cli.github.com" };
+  }
+  // Push branch first if needed
+  const branchR = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], opts.cwd);
+  const branch = branchR.stdout.trim();
+  const trackR = await runGit(["config", "--get", `branch.${branch}.remote`], opts.cwd);
+  if (trackR.code !== 0 || !trackR.stdout.trim()) {
+    console.log(c.gray(`Branch '${branch}' has no remote — pushing first...`));
+    const pushR = await runGit(["push", "-u", "origin", branch], opts.cwd, 60_000);
+    if (pushR.code !== 0) return { ok: false, output: `Failed to push branch: ${pushR.stderr}` };
+    console.log(c.gray("Pushed."));
+  }
+  // Build gh pr create command
+  console.log(c.cyan("PR title: ") + c.bold(args.title));
+  const bodyPreview = args.body.length > 200 ? args.body.slice(0, 197) + "..." : args.body;
+  console.log(c.gray(bodyPreview));
+  if (args.base) console.log(c.gray(`base: ${args.base}`));
+  if (args.draft) console.log(c.gray("(draft PR)"));
+  const approved = await confirm(c.yellow("Create this pull request?"), opts.autoYes);
+  if (!approved) return { ok: false, output: "User declined the PR." };
+  const ghArgs = ["pr", "create", "--title", args.title, "--body", args.body];
+  if (args.base) { ghArgs.push("--base"); ghArgs.push(args.base); }
+  if (args.draft) ghArgs.push("--draft");
+  return new Promise((resolve) => {
+    const child = spawn("gh", ghArgs, { cwd: opts.cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGTERM"), 30_000);
+    child.stdout.on("data", (d) => { stdout += d.toString(); });
+    child.stderr.on("data", (d) => { stderr += d.toString(); });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        resolve({ ok: false, output: `gh pr create failed (exit ${code}): ${stderr || stdout}` });
+      } else {
+        const prUrl = stdout.trim();
+        resolve({ ok: true, output: `Pull request created: ${prUrl}\n${stderr}`.trim() });
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({ ok: false, output: `gh spawn error: ${err.message}` });
+    });
+  });
+}
+
 /* ─────────────────────── todo_write ─────────────────────── */
 
 // Module-level singleton holding the current todo list for this CLI session.