@agimon-ai/doompi-git 0.0.1-alpha.11 → 0.0.1-alpha.13

package/dist/src/services/worktreeNaming/index.cjs

@@ -0,0 +1,99 @@
+//#region src/services/worktreeNaming/index.ts
+const MAX_SLUG_LENGTH = 64;
+/**
+* A branch name reduced to one safe path segment.
+*
+* Slashes are the point: `wt/fix-auth` is a perfectly good branch and a
+* terrible directory name, because the nested directory it implies is not the
+* one the worktree lives in.
+*/
+function branchSlug(branch) {
+	const slug = branch.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, MAX_SLUG_LENGTH).replace(/-+$/gu, "");
+	return slug === "" ? "worktree" : slug;
+}
+/**
+* The directory for one worktree.
+*
+* The short id disambiguates two branches whose slugs collide, such as
+* `feature/x` and `feature_x`, which would otherwise want the same directory.
+*/
+function worktreeDirectory(input) {
+	const repository = `${input.repositoryLabel}--${input.repositoryId}`;
+	return `${input.worktreesRoot}/${repository}/${branchSlug(input.branch)}--${input.shortId}`;
+}
+/** Why a worktree cannot be created, or undefined when it can. */
+function refuseSpawn(input) {
+	if (input.branch.trim() === "") return "A branch name is required.";
+	const live = input.existing.find((record) => record.branch === input.branch && record.status !== "orphaned");
+	if (live) return `Branch ${input.branch} already has a worktree (${live.id}).`;
+}
+/** Why a worktree cannot be closed, or undefined when it can. */
+function refuseClose(input) {
+	if (!input.record) return "No worktree with that id. Call list to see the current ids.";
+	if (input.dirtyFiles.length === 0 || input.force) return void 0;
+	const names = input.dirtyFiles.slice(0, 10).join(", ");
+	const more = input.dirtyFiles.length > 10 ? `, and ${String(input.dirtyFiles.length - 10)} more` : "";
+	return `${String(input.dirtyFiles.length)} uncommitted file(s): ${names}${more}. Pass force: true to discard them.`;
+}
+/**
+* Marks records whose process or directory is gone as orphaned.
+*
+* Nothing is deleted here. A doompi-git orphan owns a directory that may hold
+* uncommitted work, so losing the record would lose the only pointer to it.
+* Deletion is always a separate, named decision.
+*/
+function reconcile(records, probe) {
+	const changed = [];
+	return {
+		records: records.map((record) => {
+			if (record.status === "orphaned") return record;
+			if (!(!probe.exists(record.path) || !probe.alive(record))) return record;
+			changed.push(record.id);
+			return {
+				...record,
+				status: "orphaned"
+			};
+		}),
+		changed
+	};
+}
+/**
+* What a prune would do, decided before anything is destroyed.
+*
+* Separating the plan from the execution is what makes dryRun honest and lets
+* the destructive half be reviewed on its own.
+*/
+function planPrune(input) {
+	const plan = {
+		remove: [],
+		forget: [],
+		untracked: [],
+		keptDirty: [],
+		keptBranches: []
+	};
+	const known = new Set(input.records.map((record) => record.path));
+	const listed = new Set(input.gitPaths);
+	for (const record of input.records) {
+		if (record.status !== "orphaned") continue;
+		if (!listed.has(record.path)) {
+			plan.forget.push(record);
+			continue;
+		}
+		if ((input.dirtyByPath.get(record.path) ?? []).length > 0) {
+			plan.keptDirty.push(record);
+			continue;
+		}
+		plan.remove.push(record);
+	}
+	for (const path of input.gitPaths) if (path.startsWith(`${input.worktreesRoot}/`) && !known.has(path)) plan.untracked.push(path);
+	return plan;
+}
+//#endregion
+exports.branchSlug = branchSlug;
+exports.planPrune = planPrune;
+exports.reconcile = reconcile;
+exports.refuseClose = refuseClose;
+exports.refuseSpawn = refuseSpawn;
+exports.worktreeDirectory = worktreeDirectory;
+
+//# sourceMappingURL=index.cjs.map

package/dist/src/services/worktreeNaming/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../../src/services/worktreeNaming/index.ts"],"sourcesContent":["/**\n * Naming and reconciliation rules for worktrees, as pure functions.\n *\n * Everything here is a function of its arguments so the interesting decisions,\n * which are the ones about destroying work, can be tested without a repository\n * or a filesystem.\n */\n\nimport type { WorktreeRecord } from '../../types/worktreeRegistry';\n\nconst MAX_SLUG_LENGTH = 64;\n\n/**\n * A branch name reduced to one safe path segment.\n *\n * Slashes are the point: `wt/fix-auth` is a perfectly good branch and a\n * terrible directory name, because the nested directory it implies is not the\n * one the worktree lives in.\n */\nexport function branchSlug(branch: string): string {\n  const slug = branch\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/gu, '-')\n    .replace(/^-+|-+$/gu, '')\n    .slice(0, MAX_SLUG_LENGTH)\n    .replace(/-+$/gu, '');\n  return slug === '' ? 'worktree' : slug;\n}\n\n/**\n * The directory for one worktree.\n *\n * The short id disambiguates two branches whose slugs collide, such as\n * `feature/x` and `feature_x`, which would otherwise want the same directory.\n */\nexport function worktreeDirectory(input: {\n  worktreesRoot: string;\n  repositoryLabel: string;\n  repositoryId: string;\n  branch: string;\n  shortId: string;\n}): string {\n  const repository = `${input.repositoryLabel}--${input.repositoryId}`;\n  return `${input.worktreesRoot}/${repository}/${branchSlug(input.branch)}--${input.shortId}`;\n}\n\n/** Why a worktree cannot be created, or undefined when it can. */\nexport function refuseSpawn(input: { branch: string; existing: readonly WorktreeRecord[] }): string | undefined {\n  if (input.branch.trim() === '') return 'A branch name is required.';\n  // Git refuses a second worktree on one branch, but its message names a path\n  // the caller never chose, so this says it in the caller's own terms first.\n  const live = input.existing.find((record) => record.branch === input.branch && record.status !== 'orphaned');\n  if (live) return `Branch ${input.branch} already has a worktree (${live.id}).`;\n  return undefined;\n}\n\n/** Why a worktree cannot be closed, or undefined when it can. */\nexport function refuseClose(input: {\n  record: WorktreeRecord | undefined;\n  dirtyFiles: readonly string[];\n  force: boolean;\n}): string | undefined {\n  if (!input.record) return 'No worktree with that id. Call list to see the current ids.';\n  if (input.dirtyFiles.length === 0 || input.force) return undefined;\n  // Naming the files is the point: \"the tree is dirty\" sends the reader to go\n  // look, and the answer is usually a file they forgot rather than one they\n  // meant to keep.\n  const names = input.dirtyFiles.slice(0, 10).join(', ');\n  const more = input.dirtyFiles.length > 10 ? `, and ${String(input.dirtyFiles.length - 10)} more` : '';\n  return `${String(input.dirtyFiles.length)} uncommitted file(s): ${names}${more}. Pass force: true to discard them.`;\n}\n\nexport interface Reconciliation {\n  records: WorktreeRecord[];\n  /** Ids whose status changed, so a caller can report what it noticed. */\n  changed: string[];\n}\n\n/**\n * Marks records whose process or directory is gone as orphaned.\n *\n * Nothing is deleted here. A doompi-git orphan owns a directory that may hold\n * uncommitted work, so losing the record would lose the only pointer to it.\n * Deletion is always a separate, named decision.\n */\nexport function reconcile(\n  records: readonly WorktreeRecord[],\n  probe: { alive: (record: WorktreeRecord) => boolean; exists: (path: string) => boolean },\n): Reconciliation {\n  const changed: string[] = [];\n  const next = records.map((record) => {\n    if (record.status === 'orphaned') return record;\n    const gone = !probe.exists(record.path) || !probe.alive(record);\n    if (!gone) return record;\n    changed.push(record.id);\n    return { ...record, status: 'orphaned' as const };\n  });\n  return { records: next, changed };\n}\n\nexport interface PrunePlan {\n  /** Orphans whose directory git still lists, safe to remove. */\n  remove: WorktreeRecord[];\n  /** Orphans whose directory is already gone; drop the record only. */\n  forget: WorktreeRecord[];\n  /** Paths git lists under our root that we have no record of; report, never touch. */\n  untracked: string[];\n  /** Orphans left alone because they still hold uncommitted work. */\n  keptDirty: WorktreeRecord[];\n  /**\n   * Branches git refused to delete because they hold commits.\n   *\n   * Filled by the prune itself, not by the plan: a dry run destroys nothing, so\n   * it has nothing to report here and leaves it empty.\n   */\n  keptBranches: string[];\n}\n\n/**\n * What a prune would do, decided before anything is destroyed.\n *\n * Separating the plan from the execution is what makes dryRun honest and lets\n * the destructive half be reviewed on its own.\n */\nexport function planPrune(input: {\n  records: readonly WorktreeRecord[];\n  gitPaths: readonly string[];\n  worktreesRoot: string;\n  dirtyByPath: ReadonlyMap<string, readonly string[]>;\n}): PrunePlan {\n  const plan: PrunePlan = { remove: [], forget: [], untracked: [], keptDirty: [], keptBranches: [] };\n  const known = new Set(input.records.map((record) => record.path));\n  const listed = new Set(input.gitPaths);\n  for (const record of input.records) {\n    if (record.status !== 'orphaned') continue;\n    if (!listed.has(record.path)) {\n      plan.forget.push(record);\n      continue;\n    }\n    if ((input.dirtyByPath.get(record.path) ?? []).length > 0) {\n      plan.keptDirty.push(record);\n      continue;\n    }\n    plan.remove.push(record);\n  }\n  for (const path of input.gitPaths) {\n    // Only ever inside our own root: a worktree the user made by hand is none\n    // of this package's business, even when it looks abandoned.\n    if (path.startsWith(`${input.worktreesRoot}/`) && !known.has(path)) plan.untracked.push(path);\n  }\n  return plan;\n}\n"],"mappings":";AAUA,MAAM,kBAAkB;;;;;;;;AASxB,SAAgB,WAAW,QAAwB;CACjD,MAAM,OAAO,OACV,YAAY,CAAC,CACb,QAAQ,gBAAgB,GAAG,CAAC,CAC5B,QAAQ,aAAa,EAAE,CAAC,CACxB,MAAM,GAAG,eAAe,CAAC,CACzB,QAAQ,SAAS,EAAE;CACtB,OAAO,SAAS,KAAK,aAAa;AACpC;;;;;;;AAQA,SAAgB,kBAAkB,OAMvB;CACT,MAAM,aAAa,GAAG,MAAM,gBAAgB,IAAI,MAAM;CACtD,OAAO,GAAG,MAAM,cAAc,GAAG,WAAW,GAAG,WAAW,MAAM,MAAM,EAAE,IAAI,MAAM;AACpF;;AAGA,SAAgB,YAAY,OAAoF;CAC9G,IAAI,MAAM,OAAO,KAAK,MAAM,IAAI,OAAO;CAGvC,MAAM,OAAO,MAAM,SAAS,MAAM,WAAW,OAAO,WAAW,MAAM,UAAU,OAAO,WAAW,UAAU;CAC3G,IAAI,MAAM,OAAO,UAAU,MAAM,OAAO,2BAA2B,KAAK,GAAG;AAE7E;;AAGA,SAAgB,YAAY,OAIL;CACrB,IAAI,CAAC,MAAM,QAAQ,OAAO;CAC1B,IAAI,MAAM,WAAW,WAAW,KAAK,MAAM,OAAO,OAAO,KAAA;CAIzD,MAAM,QAAQ,MAAM,WAAW,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK,IAAI;CACrD,MAAM,OAAO,MAAM,WAAW,SAAS,KAAK,SAAS,OAAO,MAAM,WAAW,SAAS,EAAE,EAAE,SAAS;CACnG,OAAO,GAAG,OAAO,MAAM,WAAW,MAAM,EAAE,wBAAwB,QAAQ,KAAK;AACjF;;;;;;;;AAeA,SAAgB,UACd,SACA,OACgB;CAChB,MAAM,UAAoB,CAAC;CAQ3B,OAAO;EAAE,SAPI,QAAQ,KAAK,WAAW;GACnC,IAAI,OAAO,WAAW,YAAY,OAAO;GAEzC,IAAI,EADS,CAAC,MAAM,OAAO,OAAO,IAAI,KAAK,CAAC,MAAM,MAAM,MAAM,IACnD,OAAO;GAClB,QAAQ,KAAK,OAAO,EAAE;GACtB,OAAO;IAAE,GAAG;IAAQ,QAAQ;GAAoB;EAClD,CACqB;EAAG;CAAQ;AAClC;;;;;;;AA0BA,SAAgB,UAAU,OAKZ;CACZ,MAAM,OAAkB;EAAE,QAAQ,CAAC;EAAG,QAAQ,CAAC;EAAG,WAAW,CAAC;EAAG,WAAW,CAAC;EAAG,cAAc,CAAC;CAAE;CACjG,MAAM,QAAQ,IAAI,IAAI,MAAM,QAAQ,KAAK,WAAW,OAAO,IAAI,CAAC;CAChE,MAAM,SAAS,IAAI,IAAI,MAAM,QAAQ;CACrC,KAAK,MAAM,UAAU,MAAM,SAAS;EAClC,IAAI,OAAO,WAAW,YAAY;EAClC,IAAI,CAAC,OAAO,IAAI,OAAO,IAAI,GAAG;GAC5B,KAAK,OAAO,KAAK,MAAM;GACvB;EACF;EACA,KAAK,MAAM,YAAY,IAAI,OAAO,IAAI,KAAK,CAAC,EAAA,CAAG,SAAS,GAAG;GACzD,KAAK,UAAU,KAAK,MAAM;GAC1B;EACF;EACA,KAAK,OAAO,KAAK,MAAM;CACzB;CACA,KAAK,MAAM,QAAQ,MAAM,UAGvB,IAAI,KAAK,WAAW,GAAG,MAAM,cAAc,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI,GAAG,KAAK,UAAU,KAAK,IAAI;CAE9F,OAAO;AACT"}

package/dist/src/services/worktreeNaming/index.d.cts

@@ -0,0 +1,33 @@
+import { WorktreeRecord } from "../../types/worktreeRegistry.cjs";
+//#region src/services/worktreeNaming/index.d.ts
+export interface PrunePlan {
+  /** Orphans whose directory git still lists, safe to remove. */
+  remove: WorktreeRecord[];
+  /** Orphans whose directory is already gone; drop the record only. */
+  forget: WorktreeRecord[];
+  /** Paths git lists under our root that we have no record of; report, never touch. */
+  untracked: string[];
+  /** Orphans left alone because they still hold uncommitted work. */
+  keptDirty: WorktreeRecord[];
+  /**
+   * Branches git refused to delete because they hold commits.
+   *
+   * Filled by the prune itself, not by the plan: a dry run destroys nothing, so
+   * it has nothing to report here and leaves it empty.
+   */
+  keptBranches: string[];
+}
+/**
+ * What a prune would do, decided before anything is destroyed.
+ *
+ * Separating the plan from the execution is what makes dryRun honest and lets
+ * the destructive half be reviewed on its own.
+ */
+export declare function planPrune(input: {
+  records: readonly WorktreeRecord[];
+  gitPaths: readonly string[];
+  worktreesRoot: string;
+  dirtyByPath: ReadonlyMap<string, readonly string[]>;
+}): PrunePlan;
+//#endregion
+//# sourceMappingURL=index.d.cts.map

package/dist/src/services/worktreeNaming/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../../src/services/worktreeNaming/index.ts"],"mappings":";;iBAoGiB;;EAEf,QAAQ;;EAER,QAAQ;;EAER;;EAEA,WAAW;;;;;;;EAOX;;;;;;;;wBASc,UAAU;EACxB,kBAAkB;EAClB;EACA;EACA,aAAa;IACX"}

package/dist/src/services/worktreeNaming/index.d.mts

@@ -0,0 +1,33 @@
+import { WorktreeRecord } from "../../types/worktreeRegistry.mjs";
+//#region src/services/worktreeNaming/index.d.ts
+export interface PrunePlan {
+  /** Orphans whose directory git still lists, safe to remove. */
+  remove: WorktreeRecord[];
+  /** Orphans whose directory is already gone; drop the record only. */
+  forget: WorktreeRecord[];
+  /** Paths git lists under our root that we have no record of; report, never touch. */
+  untracked: string[];
+  /** Orphans left alone because they still hold uncommitted work. */
+  keptDirty: WorktreeRecord[];
+  /**
+   * Branches git refused to delete because they hold commits.
+   *
+   * Filled by the prune itself, not by the plan: a dry run destroys nothing, so
+   * it has nothing to report here and leaves it empty.
+   */
+  keptBranches: string[];
+}
+/**
+ * What a prune would do, decided before anything is destroyed.
+ *
+ * Separating the plan from the execution is what makes dryRun honest and lets
+ * the destructive half be reviewed on its own.
+ */
+export declare function planPrune(input: {
+  records: readonly WorktreeRecord[];
+  gitPaths: readonly string[];
+  worktreesRoot: string;
+  dirtyByPath: ReadonlyMap<string, readonly string[]>;
+}): PrunePlan;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/src/services/worktreeNaming/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../../src/services/worktreeNaming/index.ts"],"mappings":";;iBAoGiB;;EAEf,QAAQ;;EAER,QAAQ;;EAER;;EAEA,WAAW;;;;;;;EAOX;;;;;;;;wBASc,UAAU;EACxB,kBAAkB;EAClB;EACA;EACA,aAAa;IACX"}

package/dist/src/services/worktreeNaming/index.mjs

@@ -0,0 +1,94 @@
+//#region src/services/worktreeNaming/index.ts
+const MAX_SLUG_LENGTH = 64;
+/**
+* A branch name reduced to one safe path segment.
+*
+* Slashes are the point: `wt/fix-auth` is a perfectly good branch and a
+* terrible directory name, because the nested directory it implies is not the
+* one the worktree lives in.
+*/
+function branchSlug(branch) {
+	const slug = branch.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, MAX_SLUG_LENGTH).replace(/-+$/gu, "");
+	return slug === "" ? "worktree" : slug;
+}
+/**
+* The directory for one worktree.
+*
+* The short id disambiguates two branches whose slugs collide, such as
+* `feature/x` and `feature_x`, which would otherwise want the same directory.
+*/
+function worktreeDirectory(input) {
+	const repository = `${input.repositoryLabel}--${input.repositoryId}`;
+	return `${input.worktreesRoot}/${repository}/${branchSlug(input.branch)}--${input.shortId}`;
+}
+/** Why a worktree cannot be created, or undefined when it can. */
+function refuseSpawn(input) {
+	if (input.branch.trim() === "") return "A branch name is required.";
+	const live = input.existing.find((record) => record.branch === input.branch && record.status !== "orphaned");
+	if (live) return `Branch ${input.branch} already has a worktree (${live.id}).`;
+}
+/** Why a worktree cannot be closed, or undefined when it can. */
+function refuseClose(input) {
+	if (!input.record) return "No worktree with that id. Call list to see the current ids.";
+	if (input.dirtyFiles.length === 0 || input.force) return void 0;
+	const names = input.dirtyFiles.slice(0, 10).join(", ");
+	const more = input.dirtyFiles.length > 10 ? `, and ${String(input.dirtyFiles.length - 10)} more` : "";
+	return `${String(input.dirtyFiles.length)} uncommitted file(s): ${names}${more}. Pass force: true to discard them.`;
+}
+/**
+* Marks records whose process or directory is gone as orphaned.
+*
+* Nothing is deleted here. A doompi-git orphan owns a directory that may hold
+* uncommitted work, so losing the record would lose the only pointer to it.
+* Deletion is always a separate, named decision.
+*/
+function reconcile(records, probe) {
+	const changed = [];
+	return {
+		records: records.map((record) => {
+			if (record.status === "orphaned") return record;
+			if (!(!probe.exists(record.path) || !probe.alive(record))) return record;
+			changed.push(record.id);
+			return {
+				...record,
+				status: "orphaned"
+			};
+		}),
+		changed
+	};
+}
+/**
+* What a prune would do, decided before anything is destroyed.
+*
+* Separating the plan from the execution is what makes dryRun honest and lets
+* the destructive half be reviewed on its own.
+*/
+function planPrune(input) {
+	const plan = {
+		remove: [],
+		forget: [],
+		untracked: [],
+		keptDirty: [],
+		keptBranches: []
+	};
+	const known = new Set(input.records.map((record) => record.path));
+	const listed = new Set(input.gitPaths);
+	for (const record of input.records) {
+		if (record.status !== "orphaned") continue;
+		if (!listed.has(record.path)) {
+			plan.forget.push(record);
+			continue;
+		}
+		if ((input.dirtyByPath.get(record.path) ?? []).length > 0) {
+			plan.keptDirty.push(record);
+			continue;
+		}
+		plan.remove.push(record);
+	}
+	for (const path of input.gitPaths) if (path.startsWith(`${input.worktreesRoot}/`) && !known.has(path)) plan.untracked.push(path);
+	return plan;
+}
+//#endregion
+export { branchSlug, planPrune, reconcile, refuseClose, refuseSpawn, worktreeDirectory };
+
+//# sourceMappingURL=index.mjs.map

package/dist/src/services/worktreeNaming/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/services/worktreeNaming/index.ts"],"sourcesContent":["/**\n * Naming and reconciliation rules for worktrees, as pure functions.\n *\n * Everything here is a function of its arguments so the interesting decisions,\n * which are the ones about destroying work, can be tested without a repository\n * or a filesystem.\n */\n\nimport type { WorktreeRecord } from '../../types/worktreeRegistry';\n\nconst MAX_SLUG_LENGTH = 64;\n\n/**\n * A branch name reduced to one safe path segment.\n *\n * Slashes are the point: `wt/fix-auth` is a perfectly good branch and a\n * terrible directory name, because the nested directory it implies is not the\n * one the worktree lives in.\n */\nexport function branchSlug(branch: string): string {\n  const slug = branch\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/gu, '-')\n    .replace(/^-+|-+$/gu, '')\n    .slice(0, MAX_SLUG_LENGTH)\n    .replace(/-+$/gu, '');\n  return slug === '' ? 'worktree' : slug;\n}\n\n/**\n * The directory for one worktree.\n *\n * The short id disambiguates two branches whose slugs collide, such as\n * `feature/x` and `feature_x`, which would otherwise want the same directory.\n */\nexport function worktreeDirectory(input: {\n  worktreesRoot: string;\n  repositoryLabel: string;\n  repositoryId: string;\n  branch: string;\n  shortId: string;\n}): string {\n  const repository = `${input.repositoryLabel}--${input.repositoryId}`;\n  return `${input.worktreesRoot}/${repository}/${branchSlug(input.branch)}--${input.shortId}`;\n}\n\n/** Why a worktree cannot be created, or undefined when it can. */\nexport function refuseSpawn(input: { branch: string; existing: readonly WorktreeRecord[] }): string | undefined {\n  if (input.branch.trim() === '') return 'A branch name is required.';\n  // Git refuses a second worktree on one branch, but its message names a path\n  // the caller never chose, so this says it in the caller's own terms first.\n  const live = input.existing.find((record) => record.branch === input.branch && record.status !== 'orphaned');\n  if (live) return `Branch ${input.branch} already has a worktree (${live.id}).`;\n  return undefined;\n}\n\n/** Why a worktree cannot be closed, or undefined when it can. */\nexport function refuseClose(input: {\n  record: WorktreeRecord | undefined;\n  dirtyFiles: readonly string[];\n  force: boolean;\n}): string | undefined {\n  if (!input.record) return 'No worktree with that id. Call list to see the current ids.';\n  if (input.dirtyFiles.length === 0 || input.force) return undefined;\n  // Naming the files is the point: \"the tree is dirty\" sends the reader to go\n  // look, and the answer is usually a file they forgot rather than one they\n  // meant to keep.\n  const names = input.dirtyFiles.slice(0, 10).join(', ');\n  const more = input.dirtyFiles.length > 10 ? `, and ${String(input.dirtyFiles.length - 10)} more` : '';\n  return `${String(input.dirtyFiles.length)} uncommitted file(s): ${names}${more}. Pass force: true to discard them.`;\n}\n\nexport interface Reconciliation {\n  records: WorktreeRecord[];\n  /** Ids whose status changed, so a caller can report what it noticed. */\n  changed: string[];\n}\n\n/**\n * Marks records whose process or directory is gone as orphaned.\n *\n * Nothing is deleted here. A doompi-git orphan owns a directory that may hold\n * uncommitted work, so losing the record would lose the only pointer to it.\n * Deletion is always a separate, named decision.\n */\nexport function reconcile(\n  records: readonly WorktreeRecord[],\n  probe: { alive: (record: WorktreeRecord) => boolean; exists: (path: string) => boolean },\n): Reconciliation {\n  const changed: string[] = [];\n  const next = records.map((record) => {\n    if (record.status === 'orphaned') return record;\n    const gone = !probe.exists(record.path) || !probe.alive(record);\n    if (!gone) return record;\n    changed.push(record.id);\n    return { ...record, status: 'orphaned' as const };\n  });\n  return { records: next, changed };\n}\n\nexport interface PrunePlan {\n  /** Orphans whose directory git still lists, safe to remove. */\n  remove: WorktreeRecord[];\n  /** Orphans whose directory is already gone; drop the record only. */\n  forget: WorktreeRecord[];\n  /** Paths git lists under our root that we have no record of; report, never touch. */\n  untracked: string[];\n  /** Orphans left alone because they still hold uncommitted work. */\n  keptDirty: WorktreeRecord[];\n  /**\n   * Branches git refused to delete because they hold commits.\n   *\n   * Filled by the prune itself, not by the plan: a dry run destroys nothing, so\n   * it has nothing to report here and leaves it empty.\n   */\n  keptBranches: string[];\n}\n\n/**\n * What a prune would do, decided before anything is destroyed.\n *\n * Separating the plan from the execution is what makes dryRun honest and lets\n * the destructive half be reviewed on its own.\n */\nexport function planPrune(input: {\n  records: readonly WorktreeRecord[];\n  gitPaths: readonly string[];\n  worktreesRoot: string;\n  dirtyByPath: ReadonlyMap<string, readonly string[]>;\n}): PrunePlan {\n  const plan: PrunePlan = { remove: [], forget: [], untracked: [], keptDirty: [], keptBranches: [] };\n  const known = new Set(input.records.map((record) => record.path));\n  const listed = new Set(input.gitPaths);\n  for (const record of input.records) {\n    if (record.status !== 'orphaned') continue;\n    if (!listed.has(record.path)) {\n      plan.forget.push(record);\n      continue;\n    }\n    if ((input.dirtyByPath.get(record.path) ?? []).length > 0) {\n      plan.keptDirty.push(record);\n      continue;\n    }\n    plan.remove.push(record);\n  }\n  for (const path of input.gitPaths) {\n    // Only ever inside our own root: a worktree the user made by hand is none\n    // of this package's business, even when it looks abandoned.\n    if (path.startsWith(`${input.worktreesRoot}/`) && !known.has(path)) plan.untracked.push(path);\n  }\n  return plan;\n}\n"],"mappings":";AAUA,MAAM,kBAAkB;;;;;;;;AASxB,SAAgB,WAAW,QAAwB;CACjD,MAAM,OAAO,OACV,YAAY,CAAC,CACb,QAAQ,gBAAgB,GAAG,CAAC,CAC5B,QAAQ,aAAa,EAAE,CAAC,CACxB,MAAM,GAAG,eAAe,CAAC,CACzB,QAAQ,SAAS,EAAE;CACtB,OAAO,SAAS,KAAK,aAAa;AACpC;;;;;;;AAQA,SAAgB,kBAAkB,OAMvB;CACT,MAAM,aAAa,GAAG,MAAM,gBAAgB,IAAI,MAAM;CACtD,OAAO,GAAG,MAAM,cAAc,GAAG,WAAW,GAAG,WAAW,MAAM,MAAM,EAAE,IAAI,MAAM;AACpF;;AAGA,SAAgB,YAAY,OAAoF;CAC9G,IAAI,MAAM,OAAO,KAAK,MAAM,IAAI,OAAO;CAGvC,MAAM,OAAO,MAAM,SAAS,MAAM,WAAW,OAAO,WAAW,MAAM,UAAU,OAAO,WAAW,UAAU;CAC3G,IAAI,MAAM,OAAO,UAAU,MAAM,OAAO,2BAA2B,KAAK,GAAG;AAE7E;;AAGA,SAAgB,YAAY,OAIL;CACrB,IAAI,CAAC,MAAM,QAAQ,OAAO;CAC1B,IAAI,MAAM,WAAW,WAAW,KAAK,MAAM,OAAO,OAAO,KAAA;CAIzD,MAAM,QAAQ,MAAM,WAAW,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK,IAAI;CACrD,MAAM,OAAO,MAAM,WAAW,SAAS,KAAK,SAAS,OAAO,MAAM,WAAW,SAAS,EAAE,EAAE,SAAS;CACnG,OAAO,GAAG,OAAO,MAAM,WAAW,MAAM,EAAE,wBAAwB,QAAQ,KAAK;AACjF;;;;;;;;AAeA,SAAgB,UACd,SACA,OACgB;CAChB,MAAM,UAAoB,CAAC;CAQ3B,OAAO;EAAE,SAPI,QAAQ,KAAK,WAAW;GACnC,IAAI,OAAO,WAAW,YAAY,OAAO;GAEzC,IAAI,EADS,CAAC,MAAM,OAAO,OAAO,IAAI,KAAK,CAAC,MAAM,MAAM,MAAM,IACnD,OAAO;GAClB,QAAQ,KAAK,OAAO,EAAE;GACtB,OAAO;IAAE,GAAG;IAAQ,QAAQ;GAAoB;EAClD,CACqB;EAAG;CAAQ;AAClC;;;;;;;AA0BA,SAAgB,UAAU,OAKZ;CACZ,MAAM,OAAkB;EAAE,QAAQ,CAAC;EAAG,QAAQ,CAAC;EAAG,WAAW,CAAC;EAAG,WAAW,CAAC;EAAG,cAAc,CAAC;CAAE;CACjG,MAAM,QAAQ,IAAI,IAAI,MAAM,QAAQ,KAAK,WAAW,OAAO,IAAI,CAAC;CAChE,MAAM,SAAS,IAAI,IAAI,MAAM,QAAQ;CACrC,KAAK,MAAM,UAAU,MAAM,SAAS;EAClC,IAAI,OAAO,WAAW,YAAY;EAClC,IAAI,CAAC,OAAO,IAAI,OAAO,IAAI,GAAG;GAC5B,KAAK,OAAO,KAAK,MAAM;GACvB;EACF;EACA,KAAK,MAAM,YAAY,IAAI,OAAO,IAAI,KAAK,CAAC,EAAA,CAAG,SAAS,GAAG;GACzD,KAAK,UAAU,KAAK,MAAM;GAC1B;EACF;EACA,KAAK,OAAO,KAAK,MAAM;CACzB;CACA,KAAK,MAAM,QAAQ,MAAM,UAGvB,IAAI,KAAK,WAAW,GAAG,MAAM,cAAc,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI,GAAG,KAAK,UAAU,KAAK,IAAI;CAE9F,OAAO;AACT"}

package/dist/src/services/worktreeOperations/index.cjs

@@ -0,0 +1,324 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_index = require("../compositionMirror/index.cjs");
+const require_index$1 = require("../errors/index.cjs");
+const require_index$2 = require("../repositoryIdentity/index.cjs");
+const require_index$3 = require("../paths/index.cjs");
+const require_index$4 = require("../worktreeEvents/index.cjs");
+const require_index$5 = require("../worktreeNaming/index.cjs");
+const require_index$6 = require("../worktreeRegistry/index.cjs");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+let node_crypto = require("node:crypto");
+//#region src/services/worktreeOperations/index.ts
+const GIT_WORKTREE_DELEGATION_KIND = "git.worktree.delegation";
+const GIT_WORKTREE_MESSAGE_KIND = "git.worktree.message";
+const GIT_WORKTREE_REPORT_KIND = "git.worktree.report";
+function createWorktreeOperations(deps) {
+	const { git } = deps;
+	const sessionService = deps.sessionService;
+	const mirror = deps.mirror ?? require_index.mirrorComposition;
+	const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+	const requireSessionService = () => {
+		if (sessionService === void 0) throw new require_index$1.HubUnavailableError("The cockpit session service is unavailable. Start the cockpit and try again.");
+		return sessionService;
+	};
+	const requireMessageInbox = () => {
+		if (deps.messageInbox === void 0) throw new require_index$1.HubUnavailableError("The Git message service is unavailable. Start the cockpit and try again.");
+		return deps.messageInbox;
+	};
+	const readSessionDelivery = () => deps.sessionDelivery?.();
+	const requireSessionDelivery = () => {
+		const delivery = readSessionDelivery();
+		if (delivery === void 0) throw new require_index$1.HubUnavailableError("The Session delivery service is unavailable. Start the cockpit and try again.");
+		return delivery;
+	};
+	const probe = {
+		alive: (record) => requireSessionService().isLive(record.sessionId),
+		exists: (path) => node_fs.default.existsSync(path)
+	};
+	/**
+	* Everything an action needs about the repository it is acting on.
+	*
+	* Resolved per call rather than cached: a session's cwd is stable, but the
+	* worktree registry is shared and another process may have written it since
+	* the last call.
+	*/
+	const resolve = async (context) => {
+		const root = await git.repositoryRoot(context.cwd);
+		if (root === void 0) throw new require_index$1.DoomGitExpectedError("not_a_repository", `${context.cwd} is not inside a git repository.`, false, "Run this from a repository checkout.");
+		const store = require_index$6.createWorktreeRegistry(require_index$3.registryFile(root, deps.homeDir));
+		return {
+			root,
+			store,
+			records: store.list()
+		};
+	};
+	const require$1 = (records, id) => {
+		const record = records.find((entry) => entry.id === id);
+		if (record === void 0) throw new require_index$1.DoomGitExpectedError("worktree_not_found", `No worktree with id ${id}.`, false, "Call list to see the current ids.");
+		return record;
+	};
+	/**
+	* Refuses to destroy or merge a worktree another live session is using.
+	*
+	* `parentSessionId` records who asked for the worktree. Two sessions in one
+	* checkout share this registry, so without the check either could close the
+	* other's work in progress by id.
+	*
+	* Once that session is gone there is no owner left to protect, and refusing
+	* would strand the worktree: nothing else could ever close it.
+	*/
+	const requireOwner = (context, record, action) => {
+		if (record.parentSessionId === context.sessionId) return;
+		if (!requireSessionService().isLive(record.parentSessionId)) return;
+		throw new require_index$1.DoomGitExpectedError("worktree_not_owned", `Worktree ${record.id} belongs to another session.`, false, `Ask the session that created it to ${action} it, or close that session first.`);
+	};
+	const peerFor = (context, record) => {
+		if (context.sessionId === record.parentSessionId) return {
+			sessionId: record.sessionId,
+			party: "parent"
+		};
+		if (context.sessionId === record.sessionId) return {
+			sessionId: record.parentSessionId,
+			party: "child"
+		};
+		throw new require_index$1.DoomGitExpectedError("worktree_not_owned", `Worktree ${record.id} belongs to another session.`, false, "Use a worktree owned by this session.");
+	};
+	const requirePeerLive = (peerSessionId) => {
+		if (!requireSessionService().isLive(peerSessionId)) throw new require_index$1.DoomGitExpectedError("worktree_peer_unavailable", "The other worktree session is no longer live.", false, "Start a new worktree session before sending a message.");
+	};
+	return {
+		async spawn(context, request, options) {
+			const { root, store, records } = await resolve(context);
+			const refusal = require_index$5.refuseSpawn({
+				branch: request.branch,
+				existing: records
+			});
+			if (refusal !== void 0) throw new require_index$1.DoomGitExpectedError("worktree_exists", refusal, false, "Pick another branch name, or close it.");
+			const taskDelivery = request.task === void 0 ? void 0 : requireSessionDelivery();
+			const baseRef = request.baseRef ?? await git.currentBranch(root) ?? "HEAD";
+			const id = require_index$2.shortId((0, node_crypto.randomUUID)());
+			const path = require_index$5.worktreeDirectory({
+				worktreesRoot: require_index$3.worktreesRoot(deps.homeDir),
+				repositoryLabel: require_index$2.repositoryLabel(root),
+				repositoryId: require_index$2.repositoryId(root),
+				branch: request.branch,
+				shortId: id
+			});
+			const cancelled = () => options?.signal?.aborted === true;
+			const rollback = async () => {
+				await git.removeWorktree({
+					repositoryRoot: root,
+					path,
+					force: true
+				}).catch(() => void 0);
+				return await git.deleteBranch({
+					repositoryRoot: root,
+					branch: request.branch
+				}).catch(() => false) ? "" : ` The branch ${request.branch} has work on it and was kept.`;
+			};
+			options?.onProgress?.(`creating branch ${request.branch}\u2026`);
+			await git.addWorktree({
+				repositoryRoot: root,
+				path,
+				branch: request.branch,
+				baseRef
+			});
+			if (cancelled()) {
+				const kept = await rollback();
+				throw new require_index$1.DoomGitExpectedError("spawn_cancelled", `Cancelled before the session started.${kept}`, false, "The worktree was removed; run it again when you are ready.");
+			}
+			options?.onProgress?.("mirroring build output…");
+			mirror(root, path);
+			options?.onProgress?.("starting session…");
+			let sessionId;
+			try {
+				sessionId = (await requireSessionService().create({
+					cwd: path,
+					name: request.name ?? request.branch,
+					parentSessionId: context.sessionId,
+					sessionProvenance: "worktree",
+					...options?.signal === void 0 ? {} : { signal: options.signal }
+				})).sessionId;
+			} catch (error) {
+				const kept = await rollback();
+				if (cancelled()) throw new require_index$1.DoomGitExpectedError("spawn_cancelled", `Cancelled while the session was starting.${kept}`, false, "The worktree was removed; run it again when you are ready.");
+				if (error instanceof require_index$1.HubUnavailableError) throw new require_index$1.DoomGitExpectedError("hub_unavailable", `${error.message}${kept}`, true, "Start the cockpit and try again.");
+				throw error;
+			}
+			const record = {
+				version: 1,
+				id,
+				branch: request.branch,
+				baseRef,
+				path,
+				repositoryRoot: root,
+				sessionId,
+				parentSessionId: context.sessionId,
+				status: "running",
+				createdAt: now().toISOString()
+			};
+			try {
+				store.replace([...records, record]);
+			} catch (error) {
+				await requireSessionService().close(sessionId).catch(() => void 0);
+				const kept = await rollback();
+				throw new require_index$1.DoomGitExpectedError("registry_write_failed", `The worktree was created but the registry could not be written (${error.message}).${kept}`, true, "Check the registry file for permissions or free space, then try again.");
+			}
+			if (request.task !== void 0 && taskDelivery !== void 0) try {
+				const receipt = await taskDelivery.deliver({
+					recipientKey: sessionId,
+					kind: GIT_WORKTREE_DELEGATION_KIND,
+					prompt: request.task,
+					metadata: {
+						worktreeId: record.id,
+						fromRole: "parent",
+						text: request.task,
+						sentAt: record.createdAt
+					}
+				});
+				const admission = await taskDelivery.waitForAdmission(receipt.deliveryId);
+				if (admission !== "admitted") throw new Error(admission === "recovery_required" ? "The recipient could not admit the task." : "The recipient did not confirm task admission before the timeout.");
+			} catch (error) {
+				throw new require_index$1.DoomGitExpectedError("task_delivery_failed", `Worktree ${record.id} was created, but its task admission was not confirmed (${error.message}).`, true, `Use send with worktree ${record.id} to deliver the task without recreating the worktree.`);
+			}
+			return record;
+		},
+		async close(context, id, force) {
+			const { root, store, records } = await resolve(context);
+			const record = require$1(records, id);
+			requireOwner(context, record, "close");
+			const dirtyFiles = node_fs.default.existsSync(record.path) ? await git.dirtyFiles(record.path) : [];
+			const refusal = require_index$5.refuseClose({
+				record,
+				dirtyFiles,
+				force
+			});
+			if (refusal !== void 0) throw new require_index$1.DoomGitExpectedError("worktree_dirty", refusal, false, "Commit the work, or pass force: true.");
+			await requireSessionService().close(record.sessionId);
+			await git.removeWorktree({
+				repositoryRoot: root,
+				path: record.path,
+				force
+			});
+			store.replace(records.filter((entry) => entry.id !== id));
+			return record;
+		},
+		async list(context) {
+			const { store, records } = await resolve(context);
+			const outcome = require_index$5.reconcile(records, probe);
+			if (outcome.changed.length > 0) store.replace(outcome.records);
+			return outcome.records;
+		},
+		async status(context, id) {
+			const { records } = await resolve(context);
+			const record = require$1(records, id);
+			return {
+				record,
+				dirtyFiles: node_fs.default.existsSync(record.path) ? await git.dirtyFiles(record.path) : []
+			};
+		},
+		async merge(context, id, message) {
+			const { root, records } = await resolve(context);
+			const record = require$1(records, id);
+			requireOwner(context, record, "merge");
+			const parentDirty = await git.dirtyFiles(root);
+			if (parentDirty.length > 0) throw new require_index$1.DoomGitExpectedError("worktree_dirty", `The parent checkout has ${String(parentDirty.length)} uncommitted file(s): ${parentDirty.slice(0, 10).join(", ")}.`, false, "Commit or stash the parent checkout first.");
+			await git.mergeBranch({
+				repositoryRoot: root,
+				branch: record.branch,
+				...message === void 0 ? {} : { message }
+			});
+			return record;
+		},
+		/** Sends only between the parent session and its own worktree session. */
+		async send(context, id, message) {
+			if (Buffer.byteLength(message, "utf8") > 65536) throw new require_index$1.DoomGitExpectedError("message_too_large", `A message may not exceed ${String(require_index$4.MAX_WORKTREE_MESSAGE_BYTES)} bytes.`, false, "Send a shorter message.");
+			const { records } = await resolve(context);
+			const record = require$1(records, id);
+			const peer = peerFor(context, record);
+			requirePeerLive(peer.sessionId);
+			const sentAt = (/* @__PURE__ */ new Date()).toISOString();
+			const delivery = readSessionDelivery();
+			if (delivery !== void 0) {
+				const kind = peer.party === "parent" ? GIT_WORKTREE_MESSAGE_KIND : GIT_WORKTREE_REPORT_KIND;
+				const receipt = await delivery.deliver({
+					recipientKey: peer.sessionId,
+					kind,
+					prompt: peer.party === "parent" ? `Parent message for worktree ${record.id}:\n\n${message}` : `Report from worktree ${record.id}:\n\n${message}`,
+					metadata: {
+						worktreeId: record.id,
+						fromRole: peer.party,
+						text: message,
+						sentAt
+					}
+				});
+				const admission = await delivery.waitForAdmission(receipt.deliveryId);
+				if (admission !== "admitted") throw new require_index$1.DoomGitExpectedError("message_delivery_failed", `Worktree ${record.id} persisted the message, but its session did not confirm admission.`, true, admission === "recovery_required" ? "Call messages from the recipient session to recover the persisted text." : "The message remains durable; retry after the recipient is ready.");
+				return;
+			}
+			requireMessageInbox().send(peer.sessionId, {
+				version: 1,
+				worktreeId: record.id,
+				fromSessionId: context.sessionId,
+				from: peer.party,
+				text: message,
+				sentAt
+			});
+		},
+		async messages(context, id) {
+			const { records } = await resolve(context);
+			const record = require$1(records, id);
+			const peer = peerFor(context, record);
+			const delivery = readSessionDelivery();
+			if (delivery === void 0) return requireMessageInbox().receive(record.id);
+			return delivery.inbox({
+				consumed: false,
+				metadata: { worktreeId: record.id }
+			}).filter((entry) => entry.senderKey === peer.sessionId && (entry.state === "admitted" || entry.state === "recovery_required") && (peer.party === "parent" ? entry.kind === GIT_WORKTREE_REPORT_KIND : entry.kind === GIT_WORKTREE_MESSAGE_KIND || entry.kind === GIT_WORKTREE_DELEGATION_KIND)).map((entry) => {
+				delivery.consume(entry.deliveryId);
+				return {
+					version: 1,
+					worktreeId: record.id,
+					fromSessionId: entry.senderKey,
+					from: peer.party === "parent" ? "child" : "parent",
+					text: entry.state === "recovery_required" ? `[Recovery required: prompt admission was not confirmed] ${entry.metadata.text ?? entry.prompt}` : entry.metadata.text ?? entry.prompt,
+					sentAt: entry.metadata.sentAt ?? ""
+				};
+			});
+		},
+		async prune(context, dryRun) {
+			const { root, store, records } = await resolve(context);
+			const reconciled = require_index$5.reconcile(records, probe);
+			const gitPaths = await git.listWorktreePaths(root);
+			const dirtyByPath = /* @__PURE__ */ new Map();
+			for (const record of reconciled.records) if (record.status === "orphaned" && node_fs.default.existsSync(record.path)) dirtyByPath.set(record.path, await git.dirtyFiles(record.path));
+			const plan = require_index$5.planPrune({
+				records: reconciled.records,
+				gitPaths,
+				worktreesRoot: require_index$3.worktreesRoot(deps.homeDir),
+				dirtyByPath
+			});
+			if (dryRun) {
+				store.replace(reconciled.records);
+				return plan;
+			}
+			for (const record of plan.remove) await git.removeWorktree({
+				repositoryRoot: root,
+				path: record.path,
+				force: false
+			});
+			for (const record of [...plan.remove, ...plan.forget]) if (!await git.deleteBranch({
+				repositoryRoot: root,
+				branch: record.branch
+			}).catch(() => false)) plan.keptBranches.push(record.branch);
+			const dropped = new Set([...plan.remove, ...plan.forget].map((record) => record.id));
+			store.replace(reconciled.records.filter((record) => !dropped.has(record.id)));
+			return plan;
+		}
+	};
+}
+//#endregion
+exports.createWorktreeOperations = createWorktreeOperations;
+
+//# sourceMappingURL=index.cjs.map