@hizliemre/horse-code 0.1.0

package/dist/chunk-YBWTCXUS.js

@@ -0,0 +1,153 @@
+// src/worktree/clean.ts
+import { rm } from "fs/promises";
+import { existsSync, readdirSync, realpathSync } from "fs";
+import { join } from "path";
+var SESSIONS_DIR = join(".horsecode", "worktrees");
+async function registered(git, repoRoot) {
+  const r = await git(["worktree", "list", "--porcelain"], repoRoot);
+  const out = [];
+  for (const line of r.stdout.split("\n")) {
+    if (!line.startsWith("worktree ")) continue;
+    const p = line.slice("worktree ".length).trim();
+    try {
+      out.push(realpathSync(p));
+    } catch {
+      out.push(p);
+    }
+  }
+  return out;
+}
+async function isMerged(git, repoRoot, branch, target) {
+  const ancestor = await git(["merge-base", "--is-ancestor", branch, target], repoRoot);
+  if (ancestor.code === 0) return true;
+  const mb = await git(["merge-base", target, branch], repoRoot);
+  if (mb.code !== 0 || !mb.stdout.trim()) return false;
+  const tree = await git(["rev-parse", `${branch}^{tree}`], repoRoot);
+  if (tree.code !== 0 || !tree.stdout.trim()) return false;
+  const squashed = await git(
+    ["commit-tree", tree.stdout.trim(), "-p", mb.stdout.trim(), "-m", "hc: squash-merge probe"],
+    repoRoot
+  );
+  if (squashed.code !== 0 || !squashed.stdout.trim()) return false;
+  const cherry = await git(["cherry", target, squashed.stdout.trim()], repoRoot);
+  if (cherry.code !== 0) return false;
+  return cherry.stdout.trim().startsWith("-");
+}
+var OWN_STATE = /^\.horsecode\//;
+async function uncommitted(git, worktree) {
+  const r = await git(["status", "--porcelain"], worktree);
+  if (r.code !== 0) return [];
+  return r.stdout.split("\n").map((l) => l.slice(3).trim()).filter(Boolean);
+}
+function usersOwn(files) {
+  return files.filter((f) => !OWN_STATE.test(f.replace(/\\/g, "/")));
+}
+async function surveySessions(git, repoRoot, target) {
+  const dir = join(repoRoot, SESSIONS_DIR);
+  if (!existsSync(dir)) return [];
+  const slugs = readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  if (!slugs.length) return [];
+  const live = await registered(git, repoRoot);
+  const listed = await git(["for-each-ref", "--format=%(refname:short)", "refs/heads/hc/"], repoRoot);
+  const allBranches = listed.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  const out = [];
+  for (const slug of slugs) {
+    const root = join(dir, slug);
+    let real = root;
+    try {
+      real = realpathSync(root);
+    } catch {
+    }
+    const worktrees = live.filter((p) => p === real || p.startsWith(`${real}/`)).sort((a, b) => a.length - b.length);
+    const branches = allBranches.filter((b) => b === `hc/${slug}/base` || b.startsWith(`hc/${slug}/`));
+    const baseBranch = `hc/${slug}/base`;
+    const row = { slug, root, baseBranch, worktrees, branches };
+    if (!worktrees.length) {
+      out.push({
+        ...row,
+        verdict: "orphan",
+        detail: "git no longer tracks a worktree here \u2014 what it held cannot be checked, so it is left alone."
+      });
+      continue;
+    }
+    if (!branches.includes(baseBranch)) {
+      out.push({ ...row, verdict: "orphan", detail: `its branch \`${baseBranch}\` is gone \u2014 nothing to judge it by.` });
+      continue;
+    }
+    if (!await isMerged(git, repoRoot, baseBranch, target)) {
+      const ahead = await git(["rev-list", "--count", `${target}..${baseBranch}`], repoRoot);
+      const n = ahead.code === 0 ? ahead.stdout.trim() : "?";
+      out.push({ ...row, verdict: "unmerged", detail: `${n} commit(s) not in \`${target}\` \u2014 removing it would lose them.` });
+      continue;
+    }
+    const dirty = [];
+    let ownState = 0;
+    for (const w of worktrees) {
+      const files = await uncommitted(git, w);
+      const theirs = usersOwn(files);
+      ownState += files.length - theirs.length;
+      if (theirs.length) dirty.push(`${w.slice(root.length + 1) || "base"} (${theirs.length})`);
+    }
+    if (dirty.length) {
+      out.push({ ...row, verdict: "dirty", detail: `merged, but uncommitted changes remain in ${dirty.join(", ")}.` });
+      continue;
+    }
+    const aside = ownState ? ` (${ownState} file(s) of horse-code's own state under \`.horsecode/\` were modified and are not counted)` : "";
+    out.push({
+      ...row,
+      verdict: "merged",
+      detail: `every commit is in \`${target}\` and nothing of yours is uncommitted${aside} \u2014 ${worktrees.length} worktree(s), ${branches.length} branch(es).`
+    });
+  }
+  return out;
+}
+async function cleanSessions(git, repoRoot, target) {
+  const survey = await surveySessions(git, repoRoot, target);
+  const out = { removed: [], failed: [], kept: survey.filter((s) => s.verdict !== "merged") };
+  for (const s of survey.filter((x) => x.verdict === "merged")) {
+    try {
+      for (const w of [...s.worktrees].sort((a, b) => b.length - a.length)) {
+        await git(["worktree", "remove", "--force", w], repoRoot);
+      }
+      await rm(s.root, { recursive: true, force: true });
+      await git(["worktree", "prune"], repoRoot);
+      for (const b of s.branches) await git(["branch", "-D", b], repoRoot);
+      out.removed.push(s.slug);
+    } catch (e) {
+      out.failed.push({ slug: s.slug, error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return out;
+}
+var MARK = { merged: "\u{1F9F9}", unmerged: "\u23F3", dirty: "\u270B", orphan: "\u2753" };
+function describeSurvey(survey, target) {
+  if (!survey.length) return "No horse-code worktrees \u2014 `.horsecode/worktrees` is empty or absent.";
+  const rows = survey.map((s) => `${MARK[s.verdict]} \`${s.slug}\` \u2014 ${s.detail}`);
+  const removable = survey.filter((s) => s.verdict === "merged");
+  const head = `Judged against \`${target}\`:`;
+  const tail = removable.length ? `
+
+\`/clean-worktrees go\` removes ${removable.length === 1 ? "it" : `the ${removable.length} marked \u{1F9F9}`} \u2014 directories and branches together. Everything else is left as it is.` : `
+
+Nothing to remove.`;
+  return `${head}
+${rows.join("\n")}${tail}`;
+}
+function describeClean(res, target) {
+  const bits = [];
+  if (res.removed.length) bits.push(`\u{1F9F9} Removed ${res.removed.length} merged session(s): ${res.removed.map((s) => `\`${s}\``).join(", ")}.`);
+  else bits.push(`Nothing was merged into \`${target}\` \u2014 nothing removed.`);
+  if (res.failed.length) bits.push(`\u26A0\uFE0F Could not remove ${res.failed.map((f) => `\`${f.slug}\` (${f.error})`).join(", ")}.`);
+  if (res.kept.length) bits.push(`Kept: ${res.kept.map((s) => `\`${s.slug}\` (${s.verdict})`).join(", ")}.`);
+  return bits.join("\n\n");
+}
+
+export {
+  SESSIONS_DIR,
+  isMerged,
+  usersOwn,
+  surveySessions,
+  cleanSessions,
+  describeSurvey,
+  describeClean
+};