@diologue/local-agent 0.6.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: execFile3 } = await import("node:child_process");
+  const { execFile: execFile4 } = await import("node:child_process");
   return new Promise((resolve, reject) => {
-    const child = execFile3(
+    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";
@@ -915,6 +949,71 @@ var pickDirectory = async () => {
   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)
@@ -926,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),
@@ -1001,6 +1104,63 @@ var createRepoRouter = (state) => {
       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) {