@adriandmitroca/relay 0.0.2

package/src/sources/types.ts

@@ -0,0 +1,20 @@
+export type Severity = "critical" | "high" | "medium" | "low";
+
+export interface NormalizedIssue {
+  source: string;
+  sourceId: string;
+  externalUrl: string;
+  projectKey: string;
+  title: string;
+  body: string;
+  severity: Severity;
+  metadata: Record<string, unknown>;
+}
+
+export interface SourceAdapter {
+  name: string;
+  poll(projectKey: string): Promise<NormalizedIssue[]>;
+  getIssueContext(issue: NormalizedIssue): Promise<string>;
+  onFixAccepted?(issue: NormalizedIssue, prUrl: string): Promise<void>;
+  onFixDiscarded?(issue: NormalizedIssue): Promise<void>;
+}

package/src/utils/html.ts

@@ -0,0 +1,23 @@
+export function esc(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+/** Decode HTML entities that may already be encoded in source data (e.g. Sentry titles). */
+export function decodeHtmlEntities(s: string): string {
+  return s
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'");
+}
+
+/** Sanitize a string for use as a Telegram forum topic name (plain text, no parse mode).
+ *  Replaces angle brackets with Unicode equivalents so they don't confuse Telegram clients. */
+export function sanitizeTopicName(s: string): string {
+  return decodeHtmlEntities(s)
+    .replace(/</g, "\u2039") // ‹
+    .replace(/>/g, "\u203A") // ›
+    .replace(/\s+/g, " ")
+    .trim();
+}

package/src/utils/logger.ts

@@ -0,0 +1,49 @@
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 } as const;
+type Level = keyof typeof LEVELS;
+
+const COLORS: Record<Level, string> = {
+  debug: "\x1b[90m",
+  info: "\x1b[36m",
+  warn: "\x1b[33m",
+  error: "\x1b[31m",
+};
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+
+let minLevel: Level = "info";
+let fileWriter: ReturnType<ReturnType<typeof Bun.file>["writer"]> | null = null;
+
+export function setLogLevel(level: Level) {
+  minLevel = level;
+}
+
+export async function setLogFile(path: string) {
+  fileWriter = Bun.file(path).writer();
+}
+
+function timestamp(): string {
+  const d = new Date();
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+}
+
+function log(level: Level, msg: string, data?: Record<string, unknown>) {
+  if (LEVELS[level] < LEVELS[minLevel]) return;
+  const ts = timestamp();
+  const label = level.toUpperCase().padEnd(5);
+  const kvs = data
+    ? " " + Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ")
+    : "";
+  const colored = `${COLORS[level]}[${ts}] ${BOLD}${label}${RESET}${COLORS[level]} ${msg}${kvs}${RESET}`;
+  Bun.write(Bun.stderr, colored + "\n");
+  if (fileWriter) {
+    fileWriter.write(`[${ts}] ${label} ${msg}${kvs}\n`);
+    fileWriter.flush();
+  }
+}
+
+export const logger = {
+  debug: (msg: string, data?: Record<string, unknown>) => log("debug", msg, data),
+  info: (msg: string, data?: Record<string, unknown>) => log("info", msg, data),
+  warn: (msg: string, data?: Record<string, unknown>) => log("warn", msg, data),
+  error: (msg: string, data?: Record<string, unknown>) => log("error", msg, data),
+};

package/src/worker/claude.ts

@@ -0,0 +1,297 @@
+import { appendFileSync } from "node:fs";
+import { logger } from "../utils/logger.ts";
+
+export interface ClaudeResult {
+  success: boolean;
+  output: string;
+  error?: string;
+  exitCode: number;
+  durationMs: number;
+  sessionId?: string;
+  inputTokens: number;
+  outputTokens: number;
+  costUsd?: number;
+}
+
+export type ClaudeStreamEvent =
+  | { type: "tool_use"; tool: string }
+  | { type: "text"; text: string }
+  | { type: "result"; text: string; sessionId?: string; costUsd?: number };
+
+export interface ClaudeOptions {
+  cwd?: string;
+  timeoutMs?: number;
+  allowedTools?: string[];
+  model?: "sonnet" | "opus" | "haiku";
+  sessionId?: string;
+  resume?: string;
+  onEvent?: (event: ClaudeStreamEvent) => void;
+  logPath?: string;
+}
+
+interface ProcessResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  durationMs: number;
+  timedOut: boolean;
+}
+
+async function spawnClaude(prompt: string, opts: ClaudeOptions): Promise<ProcessResult> {
+  const { cwd, timeoutMs = 300_000, allowedTools, model, resume, onEvent, logPath } = opts;
+  const start = performance.now();
+
+  const args = buildArgs({ prompt, allowedTools, model, resume });
+
+  logger.debug("Running Claude", { cwd, timeoutMs, model, resume: !!resume, toolCount: allowedTools?.length ?? 0 });
+
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+
+  const proc = Bun.spawn(["claude", ...args], { cwd, env, stdout: "pipe", stderr: "pipe" });
+
+  const result = await Promise.race([
+    streamProcess(proc, onEvent, logPath),
+    timeout(timeoutMs).then(() => {
+      proc.kill("SIGTERM");
+      return Bun.sleep(10_000).then(() => {
+        try { proc.kill("SIGKILL"); } catch {}
+        return { stdout: "", stderr: "", exitCode: -1, timedOut: true as const };
+      });
+    }),
+  ]);
+
+  const durationMs = Math.round(performance.now() - start);
+
+  if ("timedOut" in result && result.timedOut) {
+    logger.warn("Claude timed out", { durationMs, timeoutMs });
+    return { stdout: "", stderr: "", exitCode: -1, durationMs, timedOut: true };
+  }
+
+  return { ...result, durationMs, timedOut: false };
+}
+
+export async function runClaudeText(prompt: string, opts: ClaudeOptions = {}): Promise<ClaudeResult> {
+  const result = await spawnClaude(prompt, opts);
+
+  if (result.timedOut) {
+    return { success: false, output: "", error: `Timed out after ${opts.timeoutMs ?? 300_000}ms`, exitCode: -1, durationMs: result.durationMs, inputTokens: 0, outputTokens: 0 };
+  }
+
+  if (result.exitCode !== 0) {
+    logger.warn("Claude exited with error", { exitCode: result.exitCode, stderr: result.stderr.slice(0, 500) });
+    return { success: false, output: result.stdout, error: result.stderr || `Exit code ${result.exitCode}`, exitCode: result.exitCode, durationMs: result.durationMs, inputTokens: 0, outputTokens: 0 };
+  }
+
+  const parsed = parseStreamJson(result.stdout);
+  logger.debug("Claude completed", { durationMs: result.durationMs, outputLength: parsed.text.length, sessionId: parsed.sessionId, inputTokens: parsed.inputTokens, outputTokens: parsed.outputTokens });
+  return { success: true, output: parsed.text, exitCode: 0, durationMs: result.durationMs, sessionId: parsed.sessionId, inputTokens: parsed.inputTokens, outputTokens: parsed.outputTokens, costUsd: parsed.costUsd };
+}
+
+export async function runClaudeJson<T>(prompt: string, opts: ClaudeOptions = {}): Promise<{ success: boolean; data?: T; error?: string; durationMs: number; sessionId?: string; inputTokens: number; outputTokens: number; costUsd?: number }> {
+  const result = await spawnClaude(prompt, opts);
+
+  if (result.timedOut) {
+    return { success: false, error: `Timed out after ${opts.timeoutMs ?? 300_000}ms`, durationMs: result.durationMs, inputTokens: 0, outputTokens: 0 };
+  }
+
+  if (result.exitCode !== 0) {
+    return { success: false, error: result.stderr || `Exit code ${result.exitCode}`, durationMs: result.durationMs, inputTokens: 0, outputTokens: 0 };
+  }
+
+  try {
+    const parsed = parseStreamJson(result.stdout);
+    const data = extractJson(parsed.text) as T;
+    return { success: true, data, durationMs: result.durationMs, sessionId: parsed.sessionId, inputTokens: parsed.inputTokens, outputTokens: parsed.outputTokens, costUsd: parsed.costUsd };
+  } catch (err) {
+    logger.warn("Failed to parse Claude JSON output", { error: String(err), stdout: result.stdout.slice(0, 300) });
+    return { success: false, error: `Failed to parse JSON: ${result.stdout.slice(0, 200)}`, durationMs: result.durationMs, inputTokens: 0, outputTokens: 0 };
+  }
+}
+
+function buildArgs(opts: {
+  prompt: string;
+  allowedTools?: string[];
+  model?: string;
+  resume?: string;
+}): string[] {
+  const args: string[] = [];
+
+  if (opts.resume) {
+    args.push("--resume", opts.resume, "-p", opts.prompt);
+  } else {
+    args.push("-p", opts.prompt);
+  }
+
+  args.push("--dangerously-skip-permissions", "--verbose", "--output-format", "stream-json");
+
+  if (opts.model) {
+    args.push("--model", opts.model);
+  }
+
+  if (opts.allowedTools?.length) {
+    for (const tool of opts.allowedTools) {
+      args.push("--allowedTools", tool);
+    }
+  }
+
+  return args;
+}
+
+export function parseStreamJson(stdout: string): { text: string; sessionId?: string; inputTokens: number; outputTokens: number; costUsd?: number } {
+  const lines = stdout.split("\n").filter((l) => l.trim());
+  let sessionId: string | undefined;
+  let resultText: string | undefined;
+  let costUsd: number | undefined;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  const textParts: string[] = [];
+
+  for (const line of lines) {
+    let event: Record<string, unknown>;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (event.type === "system" && typeof event.session_id === "string") {
+      sessionId = event.session_id;
+    }
+
+    if (event.type === "message_start") {
+      const msg = event.message as Record<string, unknown> | undefined;
+      const usage = msg?.usage as Record<string, unknown> | undefined;
+      if (typeof usage?.input_tokens === "number") inputTokens += usage.input_tokens;
+    }
+
+    if (event.type === "message_delta") {
+      const usage = event.usage as Record<string, unknown> | undefined;
+      if (typeof usage?.output_tokens === "number") outputTokens += usage.output_tokens;
+    }
+
+    if (event.type === "content_block_delta") {
+      const delta = event.delta as Record<string, unknown> | undefined;
+      if (delta?.type === "text_delta" && typeof delta.text === "string") {
+        textParts.push(delta.text);
+      }
+    }
+
+    if (event.type === "assistant" && Array.isArray(event.content)) {
+      for (const block of event.content) {
+        if ((block as Record<string, unknown>).type === "text" && typeof (block as Record<string, unknown>).text === "string") {
+          textParts.push((block as Record<string, unknown>).text as string);
+        }
+      }
+    }
+
+    if (event.type === "result") {
+      if (typeof event.result === "string") resultText = event.result;
+      if (typeof event.session_id === "string") sessionId = event.session_id;
+      if (typeof event.cost_usd === "number") costUsd = event.cost_usd;
+    }
+  }
+
+  const text = resultText ?? textParts.join("");
+  return { text, sessionId, inputTokens, outputTokens, costUsd };
+}
+
+async function streamProcess(
+  proc: ReturnType<typeof Bun.spawn>,
+  onEvent?: (event: ClaudeStreamEvent) => void,
+  logPath?: string,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const stderrPromise = new Response(proc.stderr).text();
+
+  const reader = (proc.stdout as ReadableStream<Uint8Array>).getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const allLines: string[] = [];
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    while (buffer.includes("\n")) {
+      const idx = buffer.indexOf("\n");
+      const line = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      if (line.trim()) {
+        allLines.push(line);
+        if (logPath) appendFileSync(logPath, line + "\n");
+      }
+
+      if (onEvent) {
+        const event = parseLineToEvent(line);
+        if (event) onEvent(event);
+      }
+    }
+  }
+
+  if (buffer.trim()) {
+    allLines.push(buffer);
+    if (logPath) appendFileSync(logPath, buffer + "\n");
+    if (onEvent) {
+      const event = parseLineToEvent(buffer);
+      if (event) onEvent(event);
+    }
+  }
+
+  const [exitCode, stderr] = await Promise.all([proc.exited, stderrPromise]);
+  const stdout = allLines.join("\n");
+  return { stdout, stderr, exitCode };
+}
+
+export function parseLineToEvent(line: string): ClaudeStreamEvent | null {
+  if (!line.trim()) return null;
+
+  let event: Record<string, unknown>;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return null;
+  }
+
+  if (event.type === "content_block_start") {
+    const content = event.content_block as Record<string, unknown> | undefined;
+    if (content?.type === "tool_use" && typeof content.name === "string") {
+      return { type: "tool_use", tool: content.name };
+    }
+  }
+
+  if (event.type === "content_block_delta") {
+    const delta = event.delta as Record<string, unknown> | undefined;
+    if (delta?.type === "text_delta" && typeof delta.text === "string") {
+      return { type: "text", text: delta.text };
+    }
+  }
+
+  if (event.type === "result" && typeof event.result === "string") {
+    return {
+      type: "result",
+      text: event.result,
+      sessionId: typeof event.session_id === "string" ? event.session_id : undefined,
+      costUsd: typeof event.cost_usd === "number" ? event.cost_usd : undefined,
+    };
+  }
+
+  return null;
+}
+
+function extractJson(text: string): unknown {
+  try {
+    return JSON.parse(text);
+  } catch {}
+
+  const match = text.match(/\{[\s\S]*\}/);
+  if (match) {
+    return JSON.parse(match[0]);
+  }
+
+  throw new Error("No JSON object found in response");
+}
+
+function timeout(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/worker/fix.ts

@@ -0,0 +1,195 @@
+import { runClaudeText, type ClaudeOptions, type ClaudeStreamEvent } from "./claude.ts";
+import { hasChanges, autoCommit, hasNewCommits, getDiffSummary, getDiffPatch } from "./git.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface FixResult {
+  success: boolean;
+  summary: string;
+  diffSummary: string;
+  diffPatch: string;
+  error?: string;
+  failureReason?: string;
+  durationMs: number;
+  inputTokens: number;
+  outputTokens: number;
+  costUsd?: number;
+}
+
+export async function fixIssue(opts: {
+  issueContext: string;
+  triagePlan: string;
+  worktreePath: string;
+  baseBranch: string;
+  testCommand?: string;
+  claudeTimeout: number;
+  allowedTools: string[];
+  projectContext?: string;
+  model?: "sonnet" | "opus" | "haiku";
+  sessionId?: string;
+  onEvent?: (event: ClaudeStreamEvent) => void;
+  logPath?: string;
+}): Promise<FixResult> {
+  const { issueContext, triagePlan, worktreePath, baseBranch, testCommand, claudeTimeout, allowedTools, projectContext, model, sessionId, onEvent, logPath } = opts;
+
+  const testInstruction = testCommand
+    ? `After making your changes, run \`${testCommand}\` to verify your fix passes. Fix any test failures.`
+    : "If there are existing tests related to your changes, run them to verify nothing is broken.";
+
+  const contextSection = projectContext ? `\n## Project Context\n${projectContext}\n` : "";
+
+  const fullPrompt = `You are an AI coding agent tasked with implementing a task. You are working in a git worktree.
+${contextSection}
+## Task
+${issueContext}
+
+## Plan
+${triagePlan}
+
+## Instructions
+1. Implement the changes following the plan above
+2. ${testInstruction}
+3. Stage and commit your changes with a message: \`fix: <concise description>\`
+4. Make sure all changes are committed before finishing
+
+Important:
+- Only change what's necessary for this task
+- Don't refactor unrelated code
+- Don't add unnecessary comments or documentation
+- Ensure backward compatibility — don't change public API signatures unless required
+- If tests fail after your changes, debug and fix them`;
+
+  const resumePrompt = `Continue with the implementation. You already explored the codebase during triage — use that context.
+
+## Instructions
+1. Implement the changes following the plan from the triage phase
+2. ${testInstruction}
+3. Stage and commit your changes with a message: \`fix: <concise description>\`
+4. Make sure all changes are committed before finishing
+
+Important:
+- Only change what's necessary for this task
+- Don't refactor unrelated code
+- Don't add unnecessary comments or documentation
+- Ensure backward compatibility — don't change public API signatures unless required
+- If tests fail after your changes, debug and fix them`;
+
+  const claudeOpts: ClaudeOptions = {
+    cwd: worktreePath,
+    timeoutMs: claudeTimeout,
+    allowedTools,
+    model,
+    resume: sessionId,
+    onEvent,
+    logPath,
+  };
+
+  let result = await runClaudeText(sessionId ? resumePrompt : fullPrompt, claudeOpts);
+
+  // If resume failed, retry without it (session may be stale or cwd mismatch)
+  if (!result.success && sessionId) {
+    logger.warn("Resume failed, retrying without session", { error: result.error });
+    result = await runClaudeText(fullPrompt, { ...claudeOpts, resume: undefined });
+  }
+
+  if (!result.success) {
+    const failureReason = result.error?.includes("Timed out") ? "fix:timeout" : "fix:claude_failed";
+    return {
+      success: false,
+      summary: "",
+      diffSummary: "",
+      diffPatch: "",
+      error: result.error ?? "Claude failed",
+      failureReason,
+      durationMs: result.durationMs,
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens,
+      costUsd: result.costUsd,
+    };
+  }
+
+  // Check if Claude made changes
+  const hasCommits = await hasNewCommits(worktreePath, baseBranch);
+
+  if (!hasCommits) {
+    // Check if there are uncommitted changes and auto-commit
+    if (await hasChanges(worktreePath)) {
+      logger.info("Claude forgot to commit, validating and auto-committing");
+
+      // Run tests before auto-committing
+      if (testCommand) {
+        const testResult = await Bun.$`sh -c ${testCommand}`.quiet().nothrow().cwd(worktreePath);
+        if (testResult.exitCode !== 0) {
+          return {
+            success: false,
+            summary: "",
+            diffSummary: "",
+            diffPatch: "",
+            error: `Tests failed on uncommitted changes: ${testResult.stderr.toString().slice(0, 300)}`,
+            failureReason: "fix:tests_failed",
+            durationMs: result.durationMs,
+            inputTokens: result.inputTokens,
+            outputTokens: result.outputTokens,
+            costUsd: result.costUsd,
+          };
+        }
+      }
+
+      const committed = await autoCommit(worktreePath, "fix: automated changes");
+      if (!committed) {
+        return {
+          success: false,
+          summary: "",
+          diffSummary: "",
+          diffPatch: "",
+          error: "Changes were made but failed to commit",
+          failureReason: "fix:commit_failed",
+          durationMs: result.durationMs,
+          inputTokens: result.inputTokens,
+          outputTokens: result.outputTokens,
+          costUsd: result.costUsd,
+        };
+      }
+    } else {
+      return {
+        success: false,
+        summary: "",
+        diffSummary: "",
+        diffPatch: "",
+        error: "No changes were made",
+        failureReason: "fix:no_changes",
+        durationMs: result.durationMs,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        costUsd: result.costUsd,
+      };
+    }
+  }
+
+  const diffSummary = await getDiffSummary(worktreePath);
+  const diffPatch = await getDiffPatch(worktreePath);
+
+  // Extract a summary from Claude's output (first few meaningful lines)
+  const summary = extractSummary(result.output);
+
+  logger.info("Fix completed", { diffSummary: diffSummary.slice(0, 200) });
+
+  return {
+    success: true,
+    summary,
+    diffSummary,
+    diffPatch,
+    durationMs: result.durationMs,
+    inputTokens: result.inputTokens,
+    outputTokens: result.outputTokens,
+    costUsd: result.costUsd,
+  };
+}
+
+function extractSummary(output: string): string {
+  // Claude usually ends with a prose summary paragraph — grab the last one
+  const paragraphs = output.split(/\n\n+/).map((p) => p.trim()).filter((p) => p.length > 0);
+  const last = paragraphs[paragraphs.length - 1] ?? "";
+  // Strip code fences and keep first 2 lines max
+  const lines = last.split("\n").filter((l) => !l.startsWith("```") && l.trim().length > 0);
+  return lines.slice(0, 2).join("\n").slice(0, 300).trim();
+}

package/src/worker/git.ts

@@ -0,0 +1,111 @@
+import { logger } from "../utils/logger.ts";
+import { join, dirname } from "node:path";
+
+export interface WorktreeInfo {
+  worktreePath: string;
+  branchName: string;
+}
+
+export async function createWorktree(
+  repoPath: string,
+  source: string,
+  sourceId: string,
+  baseBranch: string,
+): Promise<WorktreeInfo> {
+  const repoParent = dirname(repoPath);
+  const worktreeDir = join(repoParent, ".relay-worktrees");
+  const worktreePath = join(worktreeDir, `fix-${source}-${sourceId}`);
+  const branchName = `relay/fix-${source}-${sourceId}`;
+
+  // Fetch latest (60s timeout to prevent hanging on slow/broken connections)
+  await Promise.race([
+    Bun.$`git -C ${repoPath} fetch origin ${baseBranch}`.quiet().nothrow(),
+    new Promise<void>((_, reject) => setTimeout(() => reject(new Error("git fetch timed out after 60s")), 60_000)),
+  ]);
+
+  // Clean up existing worktree/branch if they exist
+  await Bun.$`git -C ${repoPath} worktree remove --force ${worktreePath}`.quiet().nothrow();
+  await Bun.$`git -C ${repoPath} branch -D ${branchName}`.quiet().nothrow();
+
+  // Ensure parent dir exists
+  await Bun.$`mkdir -p ${worktreeDir}`.quiet();
+
+  // Create worktree from origin/baseBranch
+  const result = await Bun.$`git -C ${repoPath} worktree add -b ${branchName} ${worktreePath} origin/${baseBranch}`.quiet().nothrow();
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString();
+    throw new Error(`Failed to create worktree: ${stderr}`);
+  }
+
+  logger.info("Created worktree", { path: worktreePath, branch: branchName });
+  return { worktreePath, branchName };
+}
+
+export async function removeWorktree(repoPath: string, worktreePath: string, branchName: string) {
+  await Bun.$`git -C ${repoPath} worktree remove --force ${worktreePath}`.quiet().nothrow();
+  await Bun.$`git -C ${repoPath} branch -D ${branchName}`.quiet().nothrow();
+  await Bun.$`git -C ${repoPath} worktree prune`.quiet().nothrow();
+  logger.info("Removed worktree", { path: worktreePath, branch: branchName });
+}
+
+export async function pushBranch(worktreePath: string, branchName: string): Promise<void> {
+  const push = await Bun.$`git -C ${worktreePath} push -u origin ${branchName}`.quiet().nothrow();
+  if (push.exitCode !== 0) {
+    throw new Error(`Failed to push: ${push.stderr.toString()}`);
+  }
+  logger.info("Pushed branch", { branch: branchName });
+}
+
+export async function buildPRUrl(
+  worktreePath: string,
+  branchName: string,
+  baseBranch: string,
+  title: string,
+  body: string,
+): Promise<string> {
+  const repo = await getRemoteRepo(worktreePath);
+  const params = new URLSearchParams({ expand: "1", title, body });
+  return `https://github.com/${repo}/compare/${baseBranch}...${branchName}?${params.toString()}`;
+}
+
+export async function getDiffSummary(worktreePath: string): Promise<string> {
+  const result = await Bun.$`git -C ${worktreePath} diff HEAD~1 --stat`.quiet().nothrow();
+  if (result.exitCode !== 0) {
+    return "(no diff available)";
+  }
+  return result.stdout.toString().trim();
+}
+
+export async function getDiffPatch(worktreePath: string): Promise<string> {
+  const result = await Bun.$`git -C ${worktreePath} diff HEAD~1`.quiet().nothrow();
+  if (result.exitCode !== 0) {
+    return "(no diff available)";
+  }
+  return result.stdout.toString().trim();
+}
+
+export async function hasChanges(worktreePath: string): Promise<boolean> {
+  const staged = await Bun.$`git -C ${worktreePath} diff --cached --quiet`.quiet().nothrow();
+  const unstaged = await Bun.$`git -C ${worktreePath} diff --quiet`.quiet().nothrow();
+  const untracked = await Bun.$`git -C ${worktreePath} ls-files --others --exclude-standard`.quiet().nothrow();
+  return staged.exitCode !== 0 || unstaged.exitCode !== 0 || untracked.stdout.toString().trim().length > 0;
+}
+
+export async function autoCommit(worktreePath: string, message: string): Promise<boolean> {
+  await Bun.$`git -C ${worktreePath} add -A`.quiet().nothrow();
+  const result = await Bun.$`git -C ${worktreePath} commit -m ${message}`.quiet().nothrow();
+  return result.exitCode === 0;
+}
+
+export async function hasNewCommits(worktreePath: string, baseBranch: string): Promise<boolean> {
+  const result = await Bun.$`git -C ${worktreePath} log origin/${baseBranch}..HEAD --oneline`.quiet().nothrow();
+  return result.stdout.toString().trim().length > 0;
+}
+
+async function getRemoteRepo(worktreePath: string): Promise<string> {
+  const result = await Bun.$`git -C ${worktreePath} remote get-url origin`.quiet();
+  const url = result.stdout.toString().trim();
+  // Extract owner/repo from git URL
+  const match = url.match(/github\.com[:/](.+?)(?:\.git)?$/);
+  return match?.[1] ?? url;
+}