@pepps233/mendr 0.1.0

package/dist/cli.js

@@ -0,0 +1,718 @@
+#!/usr/bin/env node
+import {
+  allowedEffortsForAgent,
+  appendEvent,
+  closeReviewSession,
+  createDetachedWorktree,
+  defaultEffortForAgent,
+  defaultExec,
+  defaultMendrHome,
+  defaultModelForAgent,
+  ensureMendrHome,
+  execOk,
+  fetchPullRequestHeadBranch,
+  fetchPullRequestHeadRef,
+  getRepoRoot,
+  isEffortForAgent,
+  isTerminalReviewState,
+  readEvents,
+  readMeta,
+  readState,
+  removeWorktree,
+  reviewDir,
+  reviewsDir,
+  sessionWorktreePath,
+  validatePullRequest,
+  worktreesDir,
+  writeMeta,
+  writeState
+} from "./chunk-EGSZLVR6.js";
+
+// src/cli.ts
+import { spawn } from "child_process";
+import { realpathSync } from "fs";
+import { mkdir, readdir } from "fs/promises";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+import { Box, Text, render, useApp, useInput, useStdin } from "ink";
+import Spinner from "ink-spinner";
+import React, { useEffect, useState } from "react";
+var agents = /* @__PURE__ */ new Set(["claude", "codex"]);
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  if (args[0] === "ls") {
+    return {
+      ok: true,
+      command: "ls"
+    };
+  }
+  if (args[0] === "view" || args[0] === "kill" || args[0] === "stop") {
+    const reviewId = args[1];
+    if (!reviewId) {
+      return {
+        ok: false,
+        exitCode: 1,
+        error: `Expected a review id for ${args[0]}.`
+      };
+    }
+    return {
+      ok: true,
+      command: args[0],
+      reviewId
+    };
+  }
+  if (args[0] === "close") {
+    return {
+      ok: false,
+      exitCode: 1,
+      error: "The close command has been renamed to kill."
+    };
+  }
+  const startArgs = args[0] === "start" ? args.slice(1) : args;
+  const [agent, prArg, ...flags] = startArgs;
+  if (!isAgent(agent)) {
+    return {
+      ok: false,
+      exitCode: 1,
+      error: "Unsupported agent. Expected claude or codex."
+    };
+  }
+  const pr = normalizePr(prArg);
+  if (!pr) {
+    return {
+      ok: false,
+      exitCode: 1,
+      error: "Expected a pull request number or GitHub pull request URL."
+    };
+  }
+  const startOptions = parseStartFlags(agent, flags);
+  if (!startOptions.ok) {
+    return startOptions;
+  }
+  return {
+    ok: true,
+    command: "start",
+    agent,
+    pr,
+    maxRounds: startOptions.maxRounds,
+    ...startOptions.model ? { model: startOptions.model } : {},
+    ...startOptions.effort ? { effort: startOptions.effort } : {}
+  };
+}
+async function startReview(options) {
+  const exec = options.exec ?? defaultExec;
+  const mendrHome = options.mendrHome ?? defaultMendrHome();
+  const cwd = options.cwd ?? process.cwd();
+  const model = options.model ?? defaultModelForAgent(options.agent);
+  const effort = options.effort ?? defaultEffortForAgent(options.agent);
+  if (!isEffortForAgent(options.agent, effort)) {
+    throw new Error(
+      `Invalid ${options.agent} effort "${effort}". Expected one of: ${allowedEffortsForAgent(options.agent).join(", ")}.`
+    );
+  }
+  await preflight({
+    exec,
+    cwd,
+    agent: options.agent,
+    pr: options.pr
+  });
+  const repo = await getRepoRoot(exec, cwd);
+  const { branch, branchPushRemote } = await fetchPullRequestHeadBranch(exec, repo, options.pr);
+  await ensureMendrHome(mendrHome);
+  const id = options.createId?.() ?? await createReviewId(mendrHome);
+  const dir = reviewDir(mendrHome, id);
+  const worktreePath = sessionWorktreePath(mendrHome, id, options.pr);
+  const worktreeRef = pullRequestHeadRef(options.pr);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const initialState = {
+    phase: "starting",
+    currentStatus: "Starting",
+    issuesFound: 0,
+    issuesFixed: 0,
+    done: false,
+    capReached: false
+  };
+  let worktreeCreated = false;
+  try {
+    await mkdir(worktreesDir(mendrHome), { recursive: true });
+    await fetchPullRequestHeadRef(exec, repo, options.pr, worktreeRef);
+    await createDetachedWorktree(exec, repo, worktreePath, worktreeRef);
+    worktreeCreated = true;
+    await writeMeta(mendrHome, id, {
+      id,
+      agent: options.agent,
+      pr: options.pr,
+      repo,
+      branch,
+      branchPushRemote,
+      worktreePath,
+      startedAt,
+      pid: 0,
+      model,
+      effort,
+      maxRounds: options.maxRounds
+    });
+    await writeState(mendrHome, id, initialState);
+    const daemon = (options.spawnDaemon ?? defaultSpawnDaemon)({
+      mendrHome,
+      reviewId: id
+    });
+    daemon.unref();
+    await writeMeta(mendrHome, id, {
+      id,
+      agent: options.agent,
+      pr: options.pr,
+      repo,
+      branch,
+      branchPushRemote,
+      worktreePath,
+      startedAt,
+      pid: daemon.pid,
+      model,
+      effort,
+      maxRounds: options.maxRounds
+    });
+    return {
+      id,
+      reviewDir: dir
+    };
+  } catch (error) {
+    if (worktreeCreated) {
+      await removeWorktree(exec, repo, worktreePath);
+    }
+    await closeReviewSession(mendrHome, id);
+    throw error;
+  }
+}
+function pullRequestHeadRef(pr) {
+  return `refs/mendr/pr-${pr}/head`;
+}
+async function renderReviewList(options = {}) {
+  const mendrHome = options.mendrHome ?? defaultMendrHome();
+  const sessions = await readReviewSessions(mendrHome);
+  if (sessions.length === 0) {
+    return "No review sessions.";
+  }
+  const terminalColumns = normalizeTerminalColumns(options.terminalColumns);
+  return sessions.map((session) => formatReviewListItem(session, terminalColumns)).join("\n");
+}
+async function renderReviewViewSnapshot(options) {
+  const mendrHome = options.mendrHome ?? defaultMendrHome();
+  const identity = await resolveReviewSessionId(mendrHome, options.reviewId);
+  const [meta, state, events] = await Promise.all([
+    readMeta(mendrHome, identity.storageId),
+    readState(mendrHome, identity.storageId),
+    readEvents(mendrHome, identity.storageId)
+  ]);
+  const recentEvents = events.slice(-5).map((event) => `${event.status}: ${event.detail}`);
+  const frame = [
+    `Review ${identity.displayId}`,
+    `Agent: ${meta.agent}`,
+    `PR: ${meta.pr}`,
+    `Status: ${state.currentStatus}`,
+    `Issues: ${state.issuesFound} found, ${state.issuesFixed} fixed`,
+    state.capReached ? "Round cap reached" : "",
+    recentEvents.join("\n")
+  ].filter(Boolean).join("\n");
+  const terminal = isTerminalReviewState(state);
+  return {
+    ...state,
+    reviewId: identity.displayId,
+    agent: meta.agent,
+    pr: meta.pr,
+    recentEvents,
+    frame,
+    spinner: terminal ? "" : "."
+  };
+}
+async function closeReview(options) {
+  const mendrHome = options.mendrHome ?? defaultMendrHome();
+  const exec = options.exec ?? defaultExec;
+  const identity = await resolveReviewSessionId(mendrHome, options.reviewId);
+  const [meta, state] = await Promise.all([
+    readMeta(mendrHome, identity.storageId),
+    readState(mendrHome, identity.storageId)
+  ]);
+  if (meta.worktreePath) {
+    if (state.phase !== "complete" && state.phase !== "stopped" && state.phase !== "failed") {
+      throw new Error("Stop the review or wait for it to complete before closing this session.");
+    }
+    await removeWorktree(exec, meta.repo, meta.worktreePath);
+  }
+  await closeReviewSession(mendrHome, identity.storageId);
+}
+async function stopReview(options) {
+  const mendrHome = options.mendrHome ?? defaultMendrHome();
+  const killProcess = options.killProcess ?? process.kill;
+  const identity = await resolveReviewSessionId(mendrHome, options.reviewId);
+  const [meta, state] = await Promise.all([
+    readMeta(mendrHome, identity.storageId),
+    readState(mendrHome, identity.storageId)
+  ]);
+  let detail = "No daemon pid was recorded.";
+  if (meta.pid > 0) {
+    try {
+      killProcess(-meta.pid, "SIGTERM");
+      detail = `Sent SIGTERM to daemon process group ${meta.pid}.`;
+    } catch (error) {
+      if (error.code === "ESRCH") {
+        detail = `Daemon process group ${meta.pid} was not running.`;
+      } else {
+        throw error;
+      }
+    }
+  }
+  await writeState(mendrHome, identity.storageId, {
+    ...state,
+    phase: "stopped",
+    currentStatus: "Stopped",
+    done: true
+  });
+  await appendEvent(mendrHome, identity.storageId, {
+    status: "Stopped",
+    detail
+  });
+}
+async function startLiveReviewView(options) {
+  const app = render(
+    React.createElement(ReviewView, {
+      mendrHome: options.mendrHome,
+      reviewId: options.reviewId,
+      pollIntervalMs: options.pollIntervalMs,
+      loadSnapshot: options.loadSnapshot
+    })
+  );
+  await app.waitUntilExit();
+}
+function ReviewView(props) {
+  const { exit } = useApp();
+  const { isRawModeSupported } = useStdin();
+  const loadSnapshot = props.loadSnapshot ?? renderReviewViewSnapshot;
+  const [snapshot, setSnapshot] = useState();
+  const [error, setError] = useState();
+  useInput(
+    (input, key) => {
+      if (input.toLowerCase() === "q" || key.escape) {
+        exit();
+      }
+    },
+    { isActive: isRawModeSupported }
+  );
+  useEffect(() => {
+    let active = true;
+    let shouldExit = false;
+    async function refresh() {
+      try {
+        const next = await loadSnapshot({
+          mendrHome: props.mendrHome,
+          reviewId: props.reviewId
+        });
+        if (!active) {
+          return;
+        }
+        setSnapshot(next);
+        setError(void 0);
+        if (isTerminalReviewState(next) && !shouldExit) {
+          shouldExit = true;
+          setTimeout(() => exit(), 0);
+        }
+      } catch (refreshError) {
+        if (!active) {
+          return;
+        }
+        setError(refreshError instanceof Error ? refreshError.message : String(refreshError));
+      }
+    }
+    void refresh();
+    const interval = setInterval(refresh, props.pollIntervalMs ?? 1e3);
+    return () => {
+      active = false;
+      clearInterval(interval);
+    };
+  }, [exit, loadSnapshot, props.mendrHome, props.pollIntervalMs, props.reviewId]);
+  if (error) {
+    return React.createElement(Text, { color: "red" }, error);
+  }
+  if (!snapshot) {
+    return React.createElement(
+      Text,
+      null,
+      React.createElement(Spinner, { type: "dots" }),
+      " Loading review..."
+    );
+  }
+  const terminal = isTerminalReviewState(snapshot);
+  return React.createElement(
+    Box,
+    { flexDirection: "column" },
+    React.createElement(Text, { bold: true }, `Review ${snapshot.reviewId}`),
+    React.createElement(Text, null, `Agent: ${snapshot.agent}`),
+    React.createElement(Text, null, `PR: ${snapshot.pr}`),
+    React.createElement(
+      Text,
+      null,
+      terminal ? "" : React.createElement(Spinner, { type: "dots" }),
+      terminal ? "" : " ",
+      snapshot.currentStatus
+    ),
+    React.createElement(
+      Text,
+      null,
+      `Issues: ${snapshot.issuesFound} found, ${snapshot.issuesFixed} fixed`
+    ),
+    snapshot.capReached ? React.createElement(Text, { color: "yellow" }, "Round cap reached") : null,
+    ...snapshot.recentEvents.map(
+      (event, index) => React.createElement(Text, { key: `${index}:${event}`, dimColor: true }, event)
+    )
+  );
+}
+function isAgent(value) {
+  return value !== void 0 && agents.has(value);
+}
+function normalizePr(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (/^\d+$/.test(value)) {
+    return value;
+  }
+  const match = /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)(?:[/?#].*)?$/.exec(value);
+  return match?.[1];
+}
+function parseStartFlags(agent, flags) {
+  let maxRounds = 3;
+  let model;
+  let effort;
+  for (let index = 0; index < flags.length; index += 1) {
+    const parsedFlag = parseOptionFlag(flags[index]);
+    const flag = parsedFlag.name;
+    if (flag !== "--rounds" && flag !== "-r" && flag !== "--model" && flag !== "-m" && flag !== "--effort" && flag !== "-e") {
+      return {
+        ok: false,
+        exitCode: 1,
+        error: `Unsupported option: ${flag}`
+      };
+    }
+    const hasInlineValue = parsedFlag.value !== void 0;
+    const rawValue = parsedFlag.value ?? flags[index + 1];
+    if (!rawValue) {
+      return {
+        ok: false,
+        exitCode: 1,
+        error: `Missing value for ${flag}.`
+      };
+    }
+    if (!hasInlineValue && (flag === "--model" || flag === "-m" || flag === "--effort" || flag === "-e") && rawValue.startsWith("-")) {
+      return {
+        ok: false,
+        exitCode: 1,
+        error: `Missing value for ${flag}.`
+      };
+    }
+    if (!hasInlineValue) {
+      index += 1;
+    }
+    if (flag === "--rounds" || flag === "-r") {
+      const parsed = Number(rawValue);
+      if (!Number.isInteger(parsed) || parsed < 1) {
+        return {
+          ok: false,
+          exitCode: 1,
+          error: "Invalid rounds value. Expected a positive integer."
+        };
+      }
+      maxRounds = parsed;
+      continue;
+    }
+    if (flag === "--model" || flag === "-m") {
+      model = rawValue;
+      continue;
+    }
+    if (!isEffortForAgent(agent, rawValue)) {
+      return {
+        ok: false,
+        exitCode: 1,
+        error: `Invalid ${agent} effort. Expected one of: ${allowedEffortsForAgent(agent).join(", ")}.`
+      };
+    }
+    effort = rawValue;
+  }
+  return {
+    ok: true,
+    maxRounds,
+    ...model ? { model } : {},
+    ...effort ? { effort } : {}
+  };
+}
+function parseOptionFlag(raw) {
+  const equalsIndex = raw.indexOf("=");
+  if (equalsIndex === -1) {
+    return { name: raw };
+  }
+  return {
+    name: raw.slice(0, equalsIndex),
+    value: raw.slice(equalsIndex + 1)
+  };
+}
+async function preflight(input) {
+  await assertBinary(input.exec, "git", ["--version"], input.cwd);
+  await assertBinary(input.exec, "gh", ["--version"], input.cwd);
+  await assertBinary(input.exec, input.agent, ["--version"], input.cwd);
+  const auth = await input.exec("gh", ["auth", "status"], { cwd: input.cwd });
+  if (auth.exitCode !== 0) {
+    throw new Error("GitHub CLI is not authenticated. Run gh auth login before starting mendr.");
+  }
+  const repo = await getRepoRoot(input.exec, input.cwd);
+  await validatePullRequest(input.exec, repo, input.pr);
+}
+async function assertBinary(exec, command, args, cwd) {
+  try {
+    await execOk(exec, command, args, { cwd });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`${command} not found. Install ${command} before starting mendr.`);
+    }
+    throw error;
+  }
+}
+function defaultSpawnDaemon(args) {
+  const daemonPath = fileURLToPath(new URL("./daemon.js", import.meta.url));
+  const child = spawn(
+    process.execPath,
+    [daemonPath, "--home", args.mendrHome, "--id", args.reviewId],
+    {
+      detached: true,
+      stdio: "ignore"
+    }
+  );
+  return {
+    pid: child.pid ?? 0,
+    unref: () => child.unref()
+  };
+}
+async function createReviewId(mendrHome) {
+  const sessions = await readReviewSessions(mendrHome);
+  let candidate = sessions.length === 0 ? 1 : Math.max(...sessions.map((session) => session.displayId)) + 1;
+  for (; ; ) {
+    const id = String(candidate);
+    try {
+      await mkdir(reviewDir(mendrHome, id));
+      return id;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        candidate += 1;
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+async function readReviewSessions(mendrHome) {
+  let entries;
+  try {
+    entries = await readdir(reviewsDir(mendrHome));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const records = await Promise.all(
+    entries.sort().map(async (id) => {
+      try {
+        const [meta, state] = await Promise.all([
+          readMeta(mendrHome, id),
+          readState(mendrHome, id)
+        ]);
+        return {
+          storageId: id,
+          meta,
+          state
+        };
+      } catch {
+        return void 0;
+      }
+    })
+  );
+  return assignDisplayIds(records.filter(isReviewSessionRecord));
+}
+function assignDisplayIds(records) {
+  const usedIds = new Set(
+    records.flatMap((record) => {
+      const numericId = parsePositiveInteger(record.storageId);
+      return numericId === void 0 ? [] : [numericId];
+    })
+  );
+  let nextLegacyId = 1;
+  const sessions = [...records].sort(compareReviewRecords).map((record) => {
+    const numericId = parsePositiveInteger(record.storageId);
+    if (numericId !== void 0) {
+      return {
+        ...record,
+        displayId: numericId
+      };
+    }
+    while (usedIds.has(nextLegacyId)) {
+      nextLegacyId += 1;
+    }
+    usedIds.add(nextLegacyId);
+    return {
+      ...record,
+      displayId: nextLegacyId++
+    };
+  });
+  return sessions.sort((a, b) => a.displayId - b.displayId);
+}
+function isReviewSessionRecord(record) {
+  return record !== void 0;
+}
+async function resolveReviewSessionId(mendrHome, requestedId) {
+  const sessions = await readReviewSessions(mendrHome);
+  const directMatch = sessions.find(
+    (session) => session.storageId === requestedId || session.meta.id === requestedId
+  );
+  if (directMatch) {
+    return {
+      storageId: directMatch.storageId,
+      displayId: String(directMatch.displayId)
+    };
+  }
+  const numericId = parsePositiveInteger(requestedId);
+  const displayMatch = numericId === void 0 ? void 0 : sessions.find((session) => session.displayId === numericId);
+  if (displayMatch) {
+    return {
+      storageId: displayMatch.storageId,
+      displayId: String(displayMatch.displayId)
+    };
+  }
+  return {
+    storageId: requestedId,
+    displayId: requestedId
+  };
+}
+function formatReviewListItem(session, terminalColumns) {
+  const summary = [
+    `${session.displayId}: ${formatAgentLabel(session.meta)}`,
+    `(PR ${session.meta.pr})`,
+    `(${session.state.currentStatus})`,
+    `(Found: ${session.state.issuesFound})`,
+    `(Fixed: ${session.state.issuesFixed})`
+  ].join(" ");
+  if (summary.length <= terminalColumns) {
+    return summary;
+  }
+  return [
+    `${session.displayId}: ${formatAgentLabel(session.meta)}`,
+    `   PR ${session.meta.pr}`,
+    `   Status: ${session.state.currentStatus}`,
+    `   Found: ${session.state.issuesFound}`,
+    `   Fixed: ${session.state.issuesFixed}`
+  ].join("\n");
+}
+function formatAgentLabel(meta) {
+  return meta.effort ? `${meta.agent}(${meta.effort})` : meta.agent;
+}
+function normalizeTerminalColumns(columns) {
+  const resolved = columns ?? process.stdout.columns ?? 80;
+  return Number.isFinite(resolved) && resolved > 0 ? resolved : 80;
+}
+function compareReviewRecords(a, b) {
+  const startedAtDiff = parseTimestamp(a.meta.startedAt) - parseTimestamp(b.meta.startedAt);
+  return startedAtDiff || a.storageId.localeCompare(b.storageId);
+}
+function parseTimestamp(value) {
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? 0 : timestamp;
+}
+function parsePositiveInteger(value) {
+  if (!/^[1-9]\d*$/.test(value)) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+async function main(argv) {
+  const program = new Command();
+  program.name("mendr").description("Run an autonomous agentic review loop on a GitHub pull request.").argument("[agent]", "agent CLI to use: claude or codex").argument("[pr]", "pull request number or GitHub pull request URL").option("-r, --rounds <n>", "maximum review and fix iterations", "3").option("-m, --model <model>", "agent model override").option("-e, --effort <effort>", "agent effort override").action(
+    async (agent, prArg, options) => {
+      if (!agent && !prArg) {
+        program.help();
+      }
+      if (agent === "close") {
+        throw new Error("The close command has been renamed to kill.");
+      }
+      if (!isAgent(agent)) {
+        throw new Error("Unsupported agent. Expected claude or codex.");
+      }
+      const pr = normalizePr(prArg);
+      if (!pr) {
+        throw new Error("Expected a pull request number or GitHub pull request URL.");
+      }
+      const flags = [
+        "--rounds",
+        options.rounds,
+        ...options.model ? ["--model", options.model] : [],
+        ...options.effort ? ["--effort", options.effort] : []
+      ];
+      const parsedOptions = parseStartFlags(agent, flags);
+      if (!parsedOptions.ok) {
+        throw new Error(parsedOptions.error);
+      }
+      const result = await startReview({
+        agent,
+        pr,
+        maxRounds: parsedOptions.maxRounds,
+        model: parsedOptions.model,
+        effort: parsedOptions.effort
+      });
+      console.log(`Started ${result.id}`);
+      console.log(`View status: mendr view ${result.id}`);
+      console.log(result.reviewDir);
+    }
+  );
+  program.command("ls").description("List review sessions.").action(async () => {
+    console.log(await renderReviewList());
+  });
+  program.command("view").description("Watch a live review status view.").argument("<id>", "review id").action(async (reviewId) => {
+    await startLiveReviewView({ reviewId });
+  });
+  program.command("stop").description("Stop a running review daemon and keep its state on disk.").argument("<id>", "review id").action(async (reviewId) => {
+    await stopReview({ reviewId });
+    console.log(`Stopped ${reviewId}`);
+  });
+  program.command("kill").description("Remove a review session from local state.").argument("<id>", "review id").action(async (reviewId) => {
+    await closeReview({ reviewId });
+    console.log(`Killed ${reviewId}`);
+  });
+  await program.parseAsync(argv);
+}
+function isCliEntrypoint(invokedPath, modulePath = fileURLToPath(import.meta.url)) {
+  if (!invokedPath) {
+    return false;
+  }
+  if (invokedPath === modulePath) {
+    return true;
+  }
+  try {
+    return realpathSync(invokedPath) === realpathSync(modulePath);
+  } catch {
+    return false;
+  }
+}
+if (isCliEntrypoint(process.argv[1])) {
+  main(process.argv).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}
+export {
+  ReviewView,
+  closeReview,
+  isCliEntrypoint,
+  parseCliArgs,
+  renderReviewList,
+  renderReviewViewSnapshot,
+  startLiveReviewView,
+  startReview,
+  stopReview
+};

package/dist/daemon.d.ts

@@ -0,0 +1,3 @@
+declare function runDaemon(argv?: string[]): Promise<void>;
+
+export { runDaemon };