@saadnvd1/agent-os 0.3.639 → 0.3.644

package/lib/stacks/testing.ts

@@ -1,7 +1,12 @@
 // Test fixtures: a project, task sessions and a stack in the test database.
 
 import { randomUUID } from "crypto";
-import { db, stackQueries as q, type StackItemStatus } from "../db";
+import {
+  db,
+  insertSessionRow,
+  stackQueries as q,
+  type StackItemStatus,
+} from "../db";
 import { createProject } from "../projects";
 
 export interface SeedItem {
@@ -28,22 +33,18 @@ export function seedStack(repo: string, specs: SeedItem[]) {
     if (!s.branch) continue;
     const id = randomUUID();
     sessions.set(s.key, id);
-    db.prepare(
-      `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id, task_status,
-         branch_name, worktree_path, base_branch, pr_number)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
+    insertSessionRow(db, {
       id,
-      s.key,
-      `claude-${id}`,
-      s.worktree ?? repo,
-      project.id,
-      s.status === "merged" ? "merged" : "running",
-      s.branch,
-      s.worktree ?? null,
-      s.baseBranch ?? null,
-      s.pr ?? null
-    );
+      name: s.key,
+      tmux_name: `claude-${id}`,
+      working_directory: s.worktree ?? repo,
+      project_id: project.id,
+      task_status: s.status === "merged" ? "merged" : "running",
+      branch_name: s.branch,
+      worktree_path: s.worktree ?? null,
+      base_branch: s.baseBranch ?? null,
+      pr_number: s.pr ?? null,
+    });
   }
   q.create(
     db,

package/lib/tasks/finish.ts

@@ -16,7 +16,8 @@ import { resolveMergedTaskAsks } from "../orchestrator/ask-settle";
 import { endSessionAgent } from "../sessions/end";
 import { run } from "./gh";
 import { pushMerged } from "../notify/push/events";
-import { gitFetch, gitPush } from "../git-exec";
+import { gitFetch } from "../git-exec";
+import { deleteTaskBranch } from "./remote-branch";
 import {
   mergePolicy,
   type MergeMethod,
@@ -40,9 +41,6 @@ import { snapshotWorktree } from "../resurrect/snapshot";
 import { keepSessionFiles } from "../session-artifacts/collect";
 import { setPr, setTask } from "../db/session-parts";
 
-// Never deleted, whatever a setting says.
-export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
-
 export const sessionMergePolicy = (session: Session): MergePolicy =>
   mergePolicy(session.project_id ? getProject(session.project_id) : null);
 
@@ -52,7 +50,14 @@ export const sessionMergePolicy = (session: Session): MergePolicy =>
 async function cleanup(
   session: Session,
   repo: string,
-  opts: { keepRemoteBranch?: boolean; merged?: MergedAs } = {}
+  opts: {
+    keepRemoteBranch?: boolean;
+    merged?: MergedAs;
+    // The head the PR merged or closed at.
+    prHead?: string | null;
+    // A drop of a task that never had a PR.
+    noPr?: boolean;
+  } = {}
 ): Promise<void> {
   const keepRemoteBranch = opts.keepRemoteBranch ?? false;
   await endSessionAgent(session);
@@ -68,14 +73,14 @@ async function cleanup(
   }
   // A stacked child's PR targets this branch: deleting it on origin would
   // make GitHub close that PR, and a closed PR can't be retargeted.
-  if (
-    session.branch_name &&
-    !keepRemoteBranch &&
-    !PROTECTED_BRANCHES.has(session.branch_name)
-  ) {
-    await gitPush(repo, ["origin", "--delete", session.branch_name]).catch(
-      () => {}
-    );
+  if (session.branch_name && !keepRemoteBranch) {
+    await deleteTaskBranch({
+      repo,
+      branch: session.branch_name,
+      prHead: opts.prHead,
+      noPr: opts.noPr,
+      keep: [session.base_branch],
+    });
   }
   await gitFetch(repo, ["--prune", "--quiet"]).catch(() => {});
   forgetPR(session.id);
@@ -112,6 +117,7 @@ async function finishMerge(
   await cleanup(session, repo, {
     keepRemoteBranch: stuck || !policy.delete_remote_branch,
     merged: { prHead },
+    prHead,
   });
   // After cleanup's fetch, so the base branch holds the merged files.
   inBackground(`re-publish docs after task ${session.id}`, () =>
@@ -257,5 +263,5 @@ export async function dropTask(id: string): Promise<void> {
   ).run(id);
   syncTaskCardInBackground(session, "dropped", pr);
   await snapshot;
-  await cleanup(session, repo);
+  await cleanup(session, repo, { prHead: pr?.head, noPr: !pr });
 }

package/lib/tasks/move-testing.ts

@@ -6,7 +6,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import { randomUUID } from "crypto";
-import { db, type Session } from "../db";
+import { db, insertSessionRow, type Session } from "../db";
 import { createProject } from "../projects";
 import { writeTranscript } from "./transcript";
 import { gitSync } from "../git-exec";
@@ -17,7 +17,7 @@ export const git = (cwd: string, ...args: string[]) =>
   gitSync(cwd, args).trim();
 
 export const row = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as Session;
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as Session;
 
 export interface MoveFixture {
   tmp: string;
@@ -71,11 +71,20 @@ export async function seedTask(
   git(f.repo, "worktree", "add", "-q", "-b", branch, cwd, "main");
   fs.writeFileSync(path.join(cwd, "work.txt"), "half done\n");
   const id = randomUUID();
-  db.prepare(
-    `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id, task_status,
-       task_prompt, branch_name, worktree_path, base_branch, claude_session_id, model)
-     VALUES (?, 'Fix it', ?, ?, ?, 'running', 'fix the thing', ?, ?, 'main', ?, 'sonnet')`
-  ).run(id, `claude-${id}`, cwd, f.projectId, branch, cwd, CLAUDE_ID);
+  insertSessionRow(db, {
+    id,
+    name: "Fix it",
+    tmux_name: `claude-${id}`,
+    working_directory: cwd,
+    project_id: f.projectId,
+    task_status: "running",
+    task_prompt: "fix the thing",
+    branch_name: branch,
+    worktree_path: cwd,
+    base_branch: "main",
+    claude_session_id: CLAUDE_ID,
+    model: "sonnet",
+  });
   await writeTranscript(
     cwd,
     CLAUDE_ID,

package/lib/tasks/pr-activity.ts

@@ -275,9 +275,19 @@ export async function failedLog(
   repo: Repo,
   url: string | null | undefined
 ): Promise<FailedLog | null> {
+  const raw = await failedJobLog(dir, repo, url);
+  return raw === null ? null : trimLog(raw);
+}
+
+// The same log whole, as gh prints it.
+export async function failedJobLog(
+  dir: string,
+  repo: Repo,
+  url: string | null | undefined
+): Promise<string | null> {
   const job = jobOf(url);
   if (!job) return null;
-  const raw = await run(
+  return run(
     "gh",
     [
       "run",
@@ -291,5 +301,4 @@ export async function failedLog(
     dir,
     60000
   );
-  return trimLog(raw);
 }

package/lib/tasks/prune-branches.ts

@@ -0,0 +1,193 @@
+// `aos branches prune`: the stale remote branches AgentOS tasks left behind.
+// A branch is stale when it is a task's recorded branch, its latest PR is
+// merged or closed at the branch's current commit, and no open PR builds on
+// it. Dry run by default; deleting goes through the same checks as a merge.
+
+import { db } from "../db";
+import { run } from "./gh";
+import { PROTECTED_BRANCHES, deleteTaskBranch } from "./remote-branch";
+
+export interface PruneRepo {
+  dir: string;
+  slug: string;
+  projectIds: string[];
+}
+
+export interface StaleBranch {
+  branch: string;
+  pr: number;
+  state: "MERGED" | "CLOSED";
+  head: string;
+}
+
+export interface RepoPrune {
+  slug: string;
+  stale: StaleBranch[];
+  kept: { branch: string; why: string }[];
+  deleted: string[];
+}
+
+interface ListedPR {
+  number: number;
+  state: string;
+  headRefName: string;
+  headRefOid: string;
+  baseRefName: string;
+  isCrossRepository: boolean;
+}
+
+const taskBranches = (projectIds: string[]): Set<string> => {
+  if (!projectIds.length) return new Set();
+  const rows = db
+    .prepare(
+      `SELECT DISTINCT branch_name FROM session_rows
+       WHERE branch_name IS NOT NULL
+         AND project_id IN (${projectIds.map(() => "?").join(", ")})`
+    )
+    .all(...projectIds) as { branch_name: string }[];
+  return new Set(rows.map((r) => r.branch_name));
+};
+
+async function remoteBranches(repo: PruneRepo): Promise<Map<string, string>> {
+  const out = await run(
+    "gh",
+    [
+      "api",
+      `repos/${repo.slug}/branches`,
+      "--paginate",
+      "--jq",
+      ".[] | [.name, .commit.sha] | @tsv",
+    ],
+    repo.dir,
+    120000
+  );
+  const tips = new Map<string, string>();
+  for (const line of out.split("\n")) {
+    const [name, sha] = line.split("\t");
+    if (name && sha) tips.set(name, sha);
+  }
+  return tips;
+}
+
+export async function pruneRepo(
+  repo: PruneRepo,
+  opts: { yes?: boolean } = {}
+): Promise<RepoPrune> {
+  const [tips, prsOut, defaultOut] = await Promise.all([
+    remoteBranches(repo),
+    run(
+      "gh",
+      [
+        "pr",
+        "list",
+        "--repo",
+        repo.slug,
+        "--state",
+        "all",
+        "--limit",
+        "1000",
+        "--json",
+        "number,state,headRefName,headRefOid,baseRefName,isCrossRepository",
+      ],
+      repo.dir,
+      120000
+    ),
+    run(
+      "gh",
+      [
+        "repo",
+        "view",
+        repo.slug,
+        "--json",
+        "defaultBranchRef",
+        "--jq",
+        ".defaultBranchRef.name",
+      ],
+      repo.dir,
+      20000
+    ),
+  ]);
+  const prs = JSON.parse(prsOut) as ListedPR[];
+  const defaultBranch = defaultOut.trim();
+  const mine = taskBranches(repo.projectIds);
+  const result: RepoPrune = {
+    slug: repo.slug,
+    stale: [],
+    kept: [],
+    deleted: [],
+  };
+  const keep = (branch: string, why: string) =>
+    result.kept.push({ branch, why });
+
+  for (const [branch, tip] of [...tips].sort()) {
+    if (branch === defaultBranch || PROTECTED_BRANCHES.has(branch)) continue;
+    if (!mine.has(branch)) {
+      keep(branch, "not an AgentOS task's branch");
+      continue;
+    }
+    const own = prs
+      .filter((p) => p.headRefName === branch && !p.isCrossRepository)
+      .sort((a, b) => b.number - a.number);
+    if (!own.length) {
+      keep(branch, "no PR");
+      continue;
+    }
+    const open = prs.find(
+      (p) =>
+        p.state === "OPEN" &&
+        (p.baseRefName === branch ||
+          (p.headRefName === branch && !p.isCrossRepository))
+    );
+    if (open) {
+      keep(branch, `open PR #${open.number}`);
+      continue;
+    }
+    const latest = own[0];
+    if (latest.headRefOid !== tip) {
+      keep(branch, `moved to ${tip.slice(0, 7)} after PR #${latest.number}`);
+      continue;
+    }
+    result.stale.push({
+      branch,
+      pr: latest.number,
+      state: latest.state as StaleBranch["state"],
+      head: latest.headRefOid,
+    });
+  }
+
+  if (opts.yes)
+    for (const s of result.stale) {
+      const out = await deleteTaskBranch({
+        repo: repo.dir,
+        slug: repo.slug,
+        branch: s.branch,
+        prHead: s.head,
+        keep: [defaultBranch],
+      });
+      if (out.deleted) result.deleted.push(s.branch);
+      else keep(s.branch, out.why);
+    }
+  return result;
+}
+
+export function pruneText(results: RepoPrune[], yes: boolean): string {
+  const lines: string[] = [];
+  let total = 0;
+  for (const r of results) {
+    lines.push(`${r.slug}:`);
+    const list = yes ? r.deleted : r.stale.map((s) => s.branch);
+    total += list.length;
+    for (const s of r.stale)
+      if (!yes || r.deleted.includes(s.branch))
+        lines.push(
+          `  ${yes ? "deleted" : "stale"}  ${s.branch}  (PR #${s.pr} ${s.state.toLowerCase()})`
+        );
+    for (const k of r.kept) lines.push(`  kept   ${k.branch}  (${k.why})`);
+  }
+  lines.push(
+    yes
+      ? `Deleted ${total} branch${total === 1 ? "" : "es"}.`
+      : `${total} stale branch${total === 1 ? "" : "es"}. Dry run: aos branches prune --yes deletes them.`
+  );
+  return lines.join("\n");
+}

package/lib/tasks/prune-scope.ts

@@ -0,0 +1,22 @@
+import { getProject } from "../projects";
+import { repoSlug } from "../git-remote";
+import { scopeProjectIds, type DoneScope } from "../done/bulk";
+import { expandHome } from "./session";
+import type { PruneRepo } from "./prune-branches";
+
+// The scope's local GitHub clones, one entry per repository (projects that
+// share one are merged, so its branches are listed once).
+export async function prunableRepos(scope: DoneScope): Promise<PruneRepo[]> {
+  const bySlug = new Map<string, PruneRepo>();
+  for (const id of scopeProjectIds(scope)) {
+    const p = getProject(id);
+    if (!p || (p.host_id && p.host_id !== "local")) continue;
+    const dir = expandHome(p.working_directory);
+    const slug = await repoSlug(dir);
+    if (!slug) continue;
+    const hit = bySlug.get(slug);
+    if (hit) hit.projectIds.push(id);
+    else bySlug.set(slug, { dir, slug, projectIds: [id] });
+  }
+  return [...bySlug.values()];
+}

package/lib/tasks/remote-branch.ts

@@ -0,0 +1,170 @@
+// Deleting a task's own branch on GitHub once its PR is merged or closed.
+// Never throws: a branch that stays is a logged line, not a failed merge.
+
+import { git, gitPush } from "../git-exec";
+import { repoSlug } from "../git-remote";
+import { run } from "./gh";
+
+// Never deleted, whatever a setting says.
+export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
+
+export interface BranchDelete {
+  deleted: boolean;
+  why: string;
+}
+
+export interface DeleteBranchOpts {
+  repo: string;
+  branch: string;
+  // The head the PR merged or closed at; the branch goes only if it is still
+  // exactly this commit.
+  prHead: string | null | undefined;
+  // A dropped task that never opened a PR has no head to compare with: its
+  // branch is rejected work and goes whatever it holds.
+  noPr?: boolean;
+  // owner/repo, when known; read from the checkout's origin otherwise.
+  slug?: string | null;
+  // Another open PR in the repo builds on this branch (decided by the caller
+  // when it knows from its own records; GitHub is asked too).
+  hasChildren?: boolean;
+  // Branches this one must never be (the default and base branches).
+  keep?: (string | null | undefined)[];
+}
+
+const gone = (error: unknown) =>
+  /HTTP (404|422)|Not Found|Reference does not exist/i.test(
+    error instanceof Error ? error.message : String(error)
+  );
+
+// repos/o/r/git/ref(s)/heads/<branch>, each path segment encoded.
+export const refPath = (slug: string, branch: string, plural: boolean) =>
+  `repos/${slug}/git/${plural ? "refs" : "ref"}/heads/${branch
+    .split("/")
+    .map(encodeURIComponent)
+    .join("/")}`;
+
+// The branch's commit on GitHub; null when it is gone.
+export async function remoteTip(
+  repo: string,
+  slug: string,
+  branch: string
+): Promise<string | null> {
+  try {
+    const out = await run(
+      "gh",
+      ["api", refPath(slug, branch, false), "--jq", ".object.sha"],
+      repo,
+      20000
+    );
+    return out.trim() || null;
+  } catch (error) {
+    if (gone(error)) return null;
+    throw error;
+  }
+}
+
+// Open PRs targeting the branch: a stacked child, which GitHub would close
+// (and could no longer retarget) if its base vanished.
+export async function openChildren(
+  repo: string,
+  slug: string,
+  branch: string
+): Promise<number[]> {
+  const out = await run(
+    "gh",
+    [
+      "pr",
+      "list",
+      "--repo",
+      slug,
+      "--base",
+      branch,
+      "--state",
+      "open",
+      "--json",
+      "number",
+    ],
+    repo,
+    20000
+  );
+  return (JSON.parse(out) as { number: number }[]).map((p) => p.number);
+}
+
+async function decide(o: DeleteBranchOpts): Promise<BranchDelete> {
+  const { repo, branch, prHead } = o;
+  if (PROTECTED_BRANCHES.has(branch))
+    return { deleted: false, why: "a protected branch" };
+  if (o.keep?.includes(branch))
+    return { deleted: false, why: "it is a base branch" };
+  if (!prHead && !o.noPr)
+    return { deleted: false, why: "no PR head was recorded" };
+  if (o.hasChildren)
+    return { deleted: false, why: "stacked cards still build on it" };
+  const slug = o.slug ?? (await repoSlug(repo));
+  if (!slug) return deleteViaGit(repo, branch, prHead || null);
+
+  const kids = await openChildren(repo, slug, branch);
+  if (kids.length)
+    return {
+      deleted: false,
+      why: `open PR ${kids.map((n) => `#${n}`).join(", ")} is based on it`,
+    };
+  const tip = await remoteTip(repo, slug, branch);
+  if (!tip) return { deleted: false, why: "already gone" };
+  if (prHead && tip !== prHead)
+    return {
+      deleted: false,
+      why: `it moved to ${tip.slice(0, 7)} after the PR's ${prHead.slice(0, 7)}`,
+    };
+  try {
+    await run(
+      "gh",
+      ["api", "-X", "DELETE", refPath(slug, branch, true)],
+      repo,
+      30000
+    );
+  } catch (error) {
+    if (!gone(error)) throw error;
+  }
+  return { deleted: true, why: "deleted" };
+}
+
+// A checkout whose origin isn't on GitHub: ask and delete through git.
+async function deleteViaGit(
+  repo: string,
+  branch: string,
+  prHead: string | null
+): Promise<BranchDelete> {
+  const line = await git(
+    repo,
+    ["ls-remote", "--heads", "origin", `refs/heads/${branch}`],
+    { timeout: 30000 }
+  );
+  const tip = line.trim().split(/\s+/)[0];
+  if (!tip) return { deleted: false, why: "already gone" };
+  if (prHead && tip !== prHead)
+    return {
+      deleted: false,
+      why: `it moved to ${tip.slice(0, 7)} after the PR's ${prHead.slice(0, 7)}`,
+    };
+  await gitPush(repo, ["origin", "--delete", branch], { timeout: 60000 });
+  return { deleted: true, why: "deleted" };
+}
+
+export async function deleteTaskBranch(
+  o: DeleteBranchOpts
+): Promise<BranchDelete> {
+  let result: BranchDelete;
+  try {
+    result = await decide(o);
+  } catch (error) {
+    const text = error instanceof Error ? error.message : String(error);
+    result = {
+      deleted: false,
+      why: `couldn't delete it: ${text.split("\n")[0].slice(0, 200)}`,
+    };
+  }
+  if (!result.deleted)
+    console.log(`[tasks] kept origin/${o.branch}: ${result.why}`);
+  return result;
+}

package/lib/tasks/testing.ts

@@ -1,7 +1,7 @@
 // Test fixtures for task PR lookups: real repositories and worktrees, with
 // gh faked by branch.
 
-import { db, type Session } from "../db";
+import { db, insertSessionRow, type Session } from "../db";
 import { createProject } from "../projects";
 import type { FindPROpts } from "./gh";
 import type { TaskPR } from "./state";
@@ -53,13 +53,19 @@ export function seedTask(
     workingDirectory: repo,
   });
   const id = crypto.randomUUID();
-  db.prepare(
-    `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id,
-       task_status, branch_name, base_branch, worktree_path)
-     VALUES (?, 'Read and execute the brief', ?, ?, ?, 'running', ?, 'main', ?)`
-  ).run(id, `claude-${id}`, worktree, project.id, branch, worktree);
+  insertSessionRow(db, {
+    id,
+    name: "Read and execute the brief",
+    tmux_name: `claude-${id}`,
+    working_directory: worktree,
+    project_id: project.id,
+    task_status: "running",
+    branch_name: branch,
+    base_branch: "main",
+    worktree_path: worktree,
+  });
   return taskRow(id);
 }
 
 export const taskRow = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as Session;
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as Session;

package/lib/worktree-sweep/commits.ts

@@ -0,0 +1,65 @@
+import { getDefaultBranch } from "../git";
+import { git as runGit } from "../git-exec";
+
+const git = (cwd: string, ...args: string[]) =>
+  runGit(cwd, args, { timeout: 60_000 }).then((out) => out.trim());
+
+const lines = (out: string) => out.split("\n").filter(Boolean);
+
+/**
+ * Commits on the worktree's HEAD that nothing else holds: not on any remote
+ * branch, not in the PR a merge took, and with no patch-equivalent commit on
+ * the base or its own remote branch (a rewritten history re-lands the same
+ * changes under new hashes). The shas, so a caller can count and name them.
+ */
+export async function unpushedCommits(
+  worktree: string,
+  repo: string,
+  opts: { prHead?: string | null; branch?: string | null } = {}
+): Promise<string[]> {
+  const head =
+    opts.prHead &&
+    (await git(
+      worktree,
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `${opts.prHead}^{commit}`
+    )
+      .then(() => [opts.prHead!])
+      .catch(() => []));
+  const stray = lines(
+    await git(
+      worktree,
+      "rev-list",
+      "HEAD",
+      "--not",
+      ...(head || []),
+      "--remotes"
+    )
+  );
+  if (!stray.length) return [];
+  const base = await getDefaultBranch(repo).catch(() => "main");
+  const upstreams: string[] = [];
+  for (const ref of [
+    `origin/${base}`,
+    opts.branch && `origin/${opts.branch}`,
+  ]) {
+    if (
+      ref &&
+      (await git(worktree, "rev-parse", "--verify", "--quiet", ref)
+        .then(() => true)
+        .catch(() => false))
+    )
+      upstreams.push(ref);
+  }
+  const left = new Set(stray);
+  for (const ref of upstreams) {
+    if (!left.size) break;
+    // "- <sha>" is a commit the upstream already has the same patch for.
+    const cherry = lines(await git(worktree, "cherry", ref, "HEAD"));
+    for (const l of cherry)
+      if (l.startsWith("- ")) left.delete(l.slice(2).trim());
+  }
+  return [...left];
+}