@diologue/local-agent 0.5.0 → 0.7.0

package/dist/cli.mjs

@@ -726,9 +726,9 @@ var getDiff = async (cwd) => {
   return [trackedDiff, ...untrackedDiffs].filter((part) => part.trim().length > 0).join("\n");
 };
 var runGitWithStdin = async (cwd, args, input) => {
-  const { execFile: execFile2 } = await import("node:child_process");
+  const { execFile: execFile4 } = await import("node:child_process");
   return new Promise((resolve, reject) => {
-    const child = execFile2(
+    const child = execFile4(
       "git",
       args,
       {
@@ -787,6 +787,40 @@ var parseDiffPaths = (unified) => {
   }
   return paths;
 };
+var getRemoteUrl = async (cwd) => {
+  try {
+    return (await runGit(cwd, ["remote", "get-url", "origin"])).trim() || null;
+  } catch (err) {
+    if (err instanceof GitCommandError) return null;
+    throw err;
+  }
+};
+var getDefaultBranch = async (cwd) => {
+  try {
+    const ref = (await runGit(cwd, ["rev-parse", "--abbrev-ref", "origin/HEAD"])).trim();
+    const name = ref.replace(/^origin\//, "");
+    return name || "main";
+  } catch (err) {
+    if (err instanceof GitCommandError) return "main";
+    throw err;
+  }
+};
+var createBranch = async (cwd, name) => {
+  await runGit(cwd, ["checkout", "-b", name]);
+};
+var commitAll = async (cwd, message) => {
+  await runGit(cwd, ["add", "-A"]);
+  await runGit(cwd, ["commit", "-m", message]);
+  return (await runGit(cwd, ["rev-parse", "--short", "HEAD"])).trim();
+};
+var pushBranch = async (cwd, branch) => {
+  await runGit(cwd, ["push", "-u", "origin", branch]);
+};
+var branchNameForTitle = (title) => {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/g, "");
+  const rand = Math.random().toString(36).slice(2, 7);
+  return `diologue/${slug || "change"}-${rand}`;
+};
 
 // src/lib/paths.ts
 import { access, lstat, realpath, stat } from "node:fs/promises";
@@ -848,6 +882,138 @@ var validateRepoPath = async (raw) => {
   return resolved;
 };
 
+// src/lib/pick-directory.ts
+import { execFile as execFile2 } from "node:child_process";
+import { homedir } from "node:os";
+var PROMPT = "Select a git repository";
+var dialogSpec = (platform) => {
+  switch (platform) {
+    case "darwin":
+      return {
+        cmd: "osascript",
+        args: [
+          "-e",
+          `set theFolder to choose folder with prompt "${PROMPT}"`,
+          "-e",
+          "POSIX path of theFolder"
+        ]
+      };
+    case "linux":
+      return {
+        cmd: "zenity",
+        args: ["--file-selection", "--directory", `--title=${PROMPT}`]
+      };
+    case "win32":
+      return {
+        cmd: "powershell",
+        args: [
+          "-NoProfile",
+          "-Command",
+          `Add-Type -AssemblyName System.Windows.Forms;$d = New-Object System.Windows.Forms.FolderBrowserDialog;$d.Description = '${PROMPT}';if ($d.ShowDialog() -eq 'OK') { Write-Output $d.SelectedPath }`
+        ]
+      };
+    default:
+      return null;
+  }
+};
+var run = (cmd, args) => new Promise((resolve, reject) => {
+  execFile2(
+    cmd,
+    args,
+    // Folder dialogs can sit open a while; cap it so the request can't hang
+    // forever if the user wanders off. Killing it reads as "cancelled".
+    { timeout: 12e4, windowsHide: true },
+    (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout);
+    }
+  );
+});
+var pickDirectory = async () => {
+  const spec = dialogSpec(process.platform);
+  if (!spec) return { ok: false, reason: "unsupported" };
+  const attempt = async (cmd, args) => {
+    try {
+      const out = (await run(cmd, args)).trim();
+      return out ? { ok: true, path: out } : { ok: false, reason: "cancelled" };
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return { ok: false, reason: "no_gui" };
+      return { ok: false, reason: "cancelled" };
+    }
+  };
+  const result = await attempt(spec.cmd, spec.args);
+  if (!result.ok && result.reason === "no_gui" && process.platform === "linux") {
+    return attempt("kdialog", ["--getexistingdirectory", homedir()]);
+  }
+  return result;
+};
+
+// src/lib/github.ts
+import { execFile as execFile3 } from "node:child_process";
+var GhError = class extends Error {
+  constructor(message, code, stderr) {
+    super(message);
+    this.code = code;
+    this.stderr = stderr;
+    this.name = "GhError";
+  }
+};
+var run2 = (args, cwd) => new Promise((resolve, reject) => {
+  execFile3(
+    "gh",
+    args,
+    { cwd, timeout: 6e4, windowsHide: true },
+    (err, stdout, stderr) => {
+      if (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+          reject(
+            new GhError(
+              "The GitHub CLI (gh) isn't installed on this machine.",
+              "gh_unavailable"
+            )
+          );
+          return;
+        }
+        reject(new GhError(stderr || err.message, "gh_failed", stderr));
+        return;
+      }
+      resolve({ stdout, stderr });
+    }
+  );
+});
+var ghReady = async () => {
+  try {
+    await run2(["auth", "status"]);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var createPullRequest = async (opts) => {
+  const { stdout } = await run2(
+    [
+      "pr",
+      "create",
+      "--base",
+      opts.base,
+      "--head",
+      opts.head,
+      "--title",
+      opts.title,
+      "--body",
+      opts.body
+    ],
+    opts.cwd
+  );
+  const url = stdout.split("\n").map((l) => l.trim()).filter(Boolean).reverse().find((l) => l.startsWith("http"));
+  if (!url) {
+    throw new GhError("gh pr create didn't return a PR URL.", "gh_failed", stdout);
+  }
+  return url;
+};
+
 // src/routes/repo.ts
 var selectRepoSchema = z.object({
   path: z.string().min(1)
@@ -859,6 +1025,10 @@ var applyPatchSchema = z.object({
 var revertPatchSchema = z.object({
   unified: z.string().min(1).max(8 * 1024 * 1024)
 });
+var createPrSchema = z.object({
+  title: z.string().min(1).max(200),
+  body: z.string().max(2e4).optional()
+});
 var buildRepoStatus = async (resolvedPath) => {
   const [branch, head, dirty] = await Promise.all([
     getBranch(resolvedPath),
@@ -917,6 +1087,80 @@ var createRepoRouter = (state) => {
       throw err;
     }
   });
+  router.post("/browse", async (_req, res) => {
+    const result = await pickDirectory();
+    if (result.ok) {
+      const body = { path: result.path };
+      res.json(body);
+      return;
+    }
+    if (result.reason === "cancelled") {
+      const body = { cancelled: true };
+      res.json(body);
+      return;
+    }
+    res.status(501).json({
+      error: result.reason,
+      message: "No desktop folder dialog is available on this machine. Type the repo path instead."
+    });
+  });
+  router.post("/create-pr", async (req, res) => {
+    const repo = requireSelectedRepo(state, res);
+    if (!repo) return;
+    const parsed = createPrSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: "invalid_body", issues: parsed.error.issues });
+      return;
+    }
+    const { title } = parsed.data;
+    const body = parsed.data.body ?? "Opened from the Diologue coding agent.";
+    const cwd = repo.path;
+    try {
+      if (!await ghReady()) {
+        res.status(501).json({
+          error: "gh_unavailable",
+          message: "GitHub CLI (gh) isn't installed or authenticated on this machine. Run `gh auth login`, or push the branch and open the PR manually."
+        });
+        return;
+      }
+      if (!await getRemoteUrl(cwd)) {
+        res.status(400).json({
+          error: "no_remote",
+          message: "This repo has no `origin` remote. Add one (git remote add origin \u2026) before creating a PR."
+        });
+        return;
+      }
+      if (!await isDirty(cwd)) {
+        res.status(409).json({
+          error: "nothing_to_commit",
+          message: "There are no changes in the working tree to open a PR for."
+        });
+        return;
+      }
+      const current = await getBranch(cwd) ?? "";
+      const onAgentBranch = current.startsWith("diologue/");
+      const base = onAgentBranch ? await getDefaultBranch(cwd) : current || "main";
+      const branch = onAgentBranch ? current : branchNameForTitle(title);
+      if (!onAgentBranch) {
+        await createBranch(cwd, branch);
+      }
+      await commitAll(cwd, title);
+      await pushBranch(cwd, branch);
+      const url = await createPullRequest({ cwd, base, head: branch, title, body });
+      const payload = { url, branch, base };
+      res.json(payload);
+    } catch (err) {
+      if (err instanceof GhError) {
+        res.status(502).json({ error: err.code, message: err.message });
+        return;
+      }
+      if (err instanceof GitCommandError) {
+        sendGitError(res, err);
+        return;
+      }
+      throw err;
+    }
+  });
   router.get("/status", async (_req, res) => {
     const repo = state.getSelectedRepo();
     if (!repo) {