@agimon-ai/doompi-git 0.0.1-alpha.7 → 0.0.1-alpha.9

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

@@ -0,0 +1,119 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+//#region src/services/compositionMirror/index.ts
+/**
+* Giving a new worktree the build output its parent checkout already has.
+*
+* DESIGN PATTERNS:
+* - Mirrors, never builds. Everything here is a copy or a symlink of something
+*   the parent checkout already produced, so it costs seconds and cannot fail
+*   the way a package manager or a compiler can.
+* - `node_modules` is linked, `dist` is copied. The module tree is gigabytes
+*   and read-only in practice, so a link is right; build output is small and a
+*   link would send a build run inside the worktree straight into the parent's
+*   directory.
+* - Absent parent output means nothing to do. A repository with no
+*   `node_modules` at its root is either not a JS project or not installed, and
+*   either way this has no opinion about it, so a Rust, Go or Python worktree
+*   pays nothing.
+*
+* WHY THIS EXISTS:
+* A DoomPi session composes the extensions its repository's config names, and
+* this repository names its own workspace packages by relative path. Those
+* packages declare `pi.extensions` under `dist/`, which git does not track, so
+* a fresh worktree resolves none of them and the session dies on start. The
+* parent checkout has already built exactly what the child needs.
+*
+* AVOID:
+* - Recursing into `node_modules`. The scan is bounded and skips it; without
+*   that this walks a gigabyte to find nothing.
+* - Treating a mirror failure as fatal. The worktree is good either way; only
+*   the session's composition is poorer for it.
+*/
+/** Directories that are build output worth copying into a new worktree. */
+const OUTPUT_DIRECTORY = "dist";
+const MODULES_DIRECTORY = "node_modules";
+const GIT_DIRECTORY = ".git";
+/**
+* How deep the scan goes.
+*
+* Four levels reaches `layers/<group>/<package>/dist` in this repository's
+* layout, and a workspace that buries a package deeper than that gets a
+* partial mirror rather than a slow one.
+*/
+const MAX_DEPTH = 4;
+function scan(root) {
+	const found = {
+		outputs: [],
+		modules: []
+	};
+	const walk = (relative, depth) => {
+		let entries;
+		try {
+			entries = node_fs.default.readdirSync(node_path.default.join(root, relative), { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			const child = relative === "" ? entry.name : `${relative}/${entry.name}`;
+			if (entry.name === GIT_DIRECTORY) continue;
+			if (entry.name === MODULES_DIRECTORY) {
+				found.modules.push(child);
+				continue;
+			}
+			if (entry.name === OUTPUT_DIRECTORY) {
+				found.outputs.push(child);
+				continue;
+			}
+			if (depth < MAX_DEPTH) walk(child, depth + 1);
+		}
+	};
+	walk("", 1);
+	return found;
+}
+/**
+* Copies the parent's build output into a worktree and links its modules.
+*
+* Individual failures are counted out rather than thrown: a mirror that lands
+* partly is still better than none, and the caller has a worktree either way.
+*/
+function mirrorComposition(source, target) {
+	if (!node_fs.default.existsSync(node_path.default.join(source, MODULES_DIRECTORY))) return {
+		kind: "skipped",
+		reason: "no-modules"
+	};
+	const found = scan(source);
+	let copied = 0;
+	let linked = 0;
+	for (const relative of found.modules) {
+		const destination = node_path.default.join(target, relative);
+		if (node_fs.default.existsSync(destination)) continue;
+		try {
+			node_fs.default.mkdirSync(node_path.default.dirname(destination), { recursive: true });
+			node_fs.default.symlinkSync(node_path.default.join(source, relative), destination, "dir");
+			linked += 1;
+		} catch {}
+	}
+	for (const relative of found.outputs) {
+		const destination = node_path.default.join(target, relative);
+		if (node_fs.default.existsSync(destination)) continue;
+		try {
+			node_fs.default.mkdirSync(node_path.default.dirname(destination), { recursive: true });
+			node_fs.default.cpSync(node_path.default.join(source, relative), destination, { recursive: true });
+			copied += 1;
+		} catch {}
+	}
+	return {
+		kind: "mirrored",
+		copied,
+		linked
+	};
+}
+//#endregion
+exports.mirrorComposition = mirrorComposition;
+
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["fs","path"],"sources":["../../../../src/services/compositionMirror/index.ts"],"sourcesContent":["/**\n * Giving a new worktree the build output its parent checkout already has.\n *\n * DESIGN PATTERNS:\n * - Mirrors, never builds. Everything here is a copy or a symlink of something\n *   the parent checkout already produced, so it costs seconds and cannot fail\n *   the way a package manager or a compiler can.\n * - `node_modules` is linked, `dist` is copied. The module tree is gigabytes\n *   and read-only in practice, so a link is right; build output is small and a\n *   link would send a build run inside the worktree straight into the parent's\n *   directory.\n * - Absent parent output means nothing to do. A repository with no\n *   `node_modules` at its root is either not a JS project or not installed, and\n *   either way this has no opinion about it, so a Rust, Go or Python worktree\n *   pays nothing.\n *\n * WHY THIS EXISTS:\n * A DoomPi session composes the extensions its repository's config names, and\n * this repository names its own workspace packages by relative path. Those\n * packages declare `pi.extensions` under `dist/`, which git does not track, so\n * a fresh worktree resolves none of them and the session dies on start. The\n * parent checkout has already built exactly what the child needs.\n *\n * AVOID:\n * - Recursing into `node_modules`. The scan is bounded and skips it; without\n *   that this walks a gigabyte to find nothing.\n * - Treating a mirror failure as fatal. The worktree is good either way; only\n *   the session's composition is poorer for it.\n */\nimport fs from 'node:fs';\nimport path from 'node:path';\n\n/** Directories that are build output worth copying into a new worktree. */\nconst OUTPUT_DIRECTORY = 'dist';\nconst MODULES_DIRECTORY = 'node_modules';\nconst GIT_DIRECTORY = '.git';\n/**\n * How deep the scan goes.\n *\n * Four levels reaches `layers/<group>/<package>/dist` in this repository's\n * layout, and a workspace that buries a package deeper than that gets a\n * partial mirror rather than a slow one.\n */\nconst MAX_DEPTH = 4;\n\nexport type MirrorOutcome =\n  | { kind: 'skipped'; reason: 'no-modules' }\n  | { kind: 'mirrored'; copied: number; linked: number };\n\ninterface Found {\n  /** Paths relative to the source root. */\n  outputs: string[];\n  modules: string[];\n}\n\nfunction scan(root: string): Found {\n  const found: Found = { outputs: [], modules: [] };\n  const walk = (relative: string, depth: number): void => {\n    let entries: fs.Dirent[];\n    try {\n      entries = fs.readdirSync(path.join(root, relative), { withFileTypes: true });\n    } catch {\n      return;\n    }\n    for (const entry of entries) {\n      if (!entry.isDirectory()) continue;\n      const child = relative === '' ? entry.name : `${relative}/${entry.name}`;\n      if (entry.name === GIT_DIRECTORY) continue;\n      // Both of these are destinations, not places to look inside.\n      if (entry.name === MODULES_DIRECTORY) {\n        found.modules.push(child);\n        continue;\n      }\n      if (entry.name === OUTPUT_DIRECTORY) {\n        found.outputs.push(child);\n        continue;\n      }\n      if (depth < MAX_DEPTH) walk(child, depth + 1);\n    }\n  };\n  walk('', 1);\n  return found;\n}\n\n/**\n * Copies the parent's build output into a worktree and links its modules.\n *\n * Individual failures are counted out rather than thrown: a mirror that lands\n * partly is still better than none, and the caller has a worktree either way.\n */\nexport function mirrorComposition(source: string, target: string): MirrorOutcome {\n  if (!fs.existsSync(path.join(source, MODULES_DIRECTORY))) return { kind: 'skipped', reason: 'no-modules' };\n\n  const found = scan(source);\n  let copied = 0;\n  let linked = 0;\n\n  for (const relative of found.modules) {\n    const destination = path.join(target, relative);\n    if (fs.existsSync(destination)) continue;\n    try {\n      fs.mkdirSync(path.dirname(destination), { recursive: true });\n      fs.symlinkSync(path.join(source, relative), destination, 'dir');\n      linked += 1;\n    } catch {\n      // A link the filesystem refuses costs this package one resolution, not\n      // the worktree.\n    }\n  }\n\n  for (const relative of found.outputs) {\n    const destination = path.join(target, relative);\n    if (fs.existsSync(destination)) continue;\n    try {\n      fs.mkdirSync(path.dirname(destination), { recursive: true });\n      fs.cpSync(path.join(source, relative), destination, { recursive: true });\n      copied += 1;\n    } catch {\n      // Same reasoning as a failed link.\n    }\n  }\n\n  return { kind: 'mirrored', copied, linked };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,MAAM,mBAAmB;AACzB,MAAM,oBAAoB;AAC1B,MAAM,gBAAgB;;;;;;;;AAQtB,MAAM,YAAY;AAYlB,SAAS,KAAK,MAAqB;CACjC,MAAM,QAAe;EAAE,SAAS,CAAC;EAAG,SAAS,CAAC;CAAE;CAChD,MAAM,QAAQ,UAAkB,UAAwB;EACtD,IAAI;EACJ,IAAI;GACF,UAAUA,QAAAA,QAAG,YAAYC,UAAAA,QAAK,KAAK,MAAM,QAAQ,GAAG,EAAE,eAAe,KAAK,CAAC;EAC7E,QAAQ;GACN;EACF;EACA,KAAK,MAAM,SAAS,SAAS;GAC3B,IAAI,CAAC,MAAM,YAAY,GAAG;GAC1B,MAAM,QAAQ,aAAa,KAAK,MAAM,OAAO,GAAG,SAAS,GAAG,MAAM;GAClE,IAAI,MAAM,SAAS,eAAe;GAElC,IAAI,MAAM,SAAS,mBAAmB;IACpC,MAAM,QAAQ,KAAK,KAAK;IACxB;GACF;GACA,IAAI,MAAM,SAAS,kBAAkB;IACnC,MAAM,QAAQ,KAAK,KAAK;IACxB;GACF;GACA,IAAI,QAAQ,WAAW,KAAK,OAAO,QAAQ,CAAC;EAC9C;CACF;CACA,KAAK,IAAI,CAAC;CACV,OAAO;AACT;;;;;;;AAQA,SAAgB,kBAAkB,QAAgB,QAA+B;CAC/E,IAAI,CAACD,QAAAA,QAAG,WAAWC,UAAAA,QAAK,KAAK,QAAQ,iBAAiB,CAAC,GAAG,OAAO;EAAE,MAAM;EAAW,QAAQ;CAAa;CAEzG,MAAM,QAAQ,KAAK,MAAM;CACzB,IAAI,SAAS;CACb,IAAI,SAAS;CAEb,KAAK,MAAM,YAAY,MAAM,SAAS;EACpC,MAAM,cAAcA,UAAAA,QAAK,KAAK,QAAQ,QAAQ;EAC9C,IAAID,QAAAA,QAAG,WAAW,WAAW,GAAG;EAChC,IAAI;GACF,QAAA,QAAG,UAAUC,UAAAA,QAAK,QAAQ,WAAW,GAAG,EAAE,WAAW,KAAK,CAAC;GAC3D,QAAA,QAAG,YAAYA,UAAAA,QAAK,KAAK,QAAQ,QAAQ,GAAG,aAAa,KAAK;GAC9D,UAAU;EACZ,QAAQ,CAGR;CACF;CAEA,KAAK,MAAM,YAAY,MAAM,SAAS;EACpC,MAAM,cAAcA,UAAAA,QAAK,KAAK,QAAQ,QAAQ;EAC9C,IAAID,QAAAA,QAAG,WAAW,WAAW,GAAG;EAChC,IAAI;GACF,QAAA,QAAG,UAAUC,UAAAA,QAAK,QAAQ,WAAW,GAAG,EAAE,WAAW,KAAK,CAAC;GAC3D,QAAA,QAAG,OAAOA,UAAAA,QAAK,KAAK,QAAQ,QAAQ,GAAG,aAAa,EAAE,WAAW,KAAK,CAAC;GACvE,UAAU;EACZ,QAAQ,CAER;CACF;CAEA,OAAO;EAAE,MAAM;EAAY;EAAQ;CAAO;AAC5C"}

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

@@ -0,0 +1,116 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/services/compositionMirror/index.ts
+/**
+* Giving a new worktree the build output its parent checkout already has.
+*
+* DESIGN PATTERNS:
+* - Mirrors, never builds. Everything here is a copy or a symlink of something
+*   the parent checkout already produced, so it costs seconds and cannot fail
+*   the way a package manager or a compiler can.
+* - `node_modules` is linked, `dist` is copied. The module tree is gigabytes
+*   and read-only in practice, so a link is right; build output is small and a
+*   link would send a build run inside the worktree straight into the parent's
+*   directory.
+* - Absent parent output means nothing to do. A repository with no
+*   `node_modules` at its root is either not a JS project or not installed, and
+*   either way this has no opinion about it, so a Rust, Go or Python worktree
+*   pays nothing.
+*
+* WHY THIS EXISTS:
+* A DoomPi session composes the extensions its repository's config names, and
+* this repository names its own workspace packages by relative path. Those
+* packages declare `pi.extensions` under `dist/`, which git does not track, so
+* a fresh worktree resolves none of them and the session dies on start. The
+* parent checkout has already built exactly what the child needs.
+*
+* AVOID:
+* - Recursing into `node_modules`. The scan is bounded and skips it; without
+*   that this walks a gigabyte to find nothing.
+* - Treating a mirror failure as fatal. The worktree is good either way; only
+*   the session's composition is poorer for it.
+*/
+/** Directories that are build output worth copying into a new worktree. */
+const OUTPUT_DIRECTORY = "dist";
+const MODULES_DIRECTORY = "node_modules";
+const GIT_DIRECTORY = ".git";
+/**
+* How deep the scan goes.
+*
+* Four levels reaches `layers/<group>/<package>/dist` in this repository's
+* layout, and a workspace that buries a package deeper than that gets a
+* partial mirror rather than a slow one.
+*/
+const MAX_DEPTH = 4;
+function scan(root) {
+	const found = {
+		outputs: [],
+		modules: []
+	};
+	const walk = (relative, depth) => {
+		let entries;
+		try {
+			entries = fs.readdirSync(path.join(root, relative), { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			const child = relative === "" ? entry.name : `${relative}/${entry.name}`;
+			if (entry.name === GIT_DIRECTORY) continue;
+			if (entry.name === MODULES_DIRECTORY) {
+				found.modules.push(child);
+				continue;
+			}
+			if (entry.name === OUTPUT_DIRECTORY) {
+				found.outputs.push(child);
+				continue;
+			}
+			if (depth < MAX_DEPTH) walk(child, depth + 1);
+		}
+	};
+	walk("", 1);
+	return found;
+}
+/**
+* Copies the parent's build output into a worktree and links its modules.
+*
+* Individual failures are counted out rather than thrown: a mirror that lands
+* partly is still better than none, and the caller has a worktree either way.
+*/
+function mirrorComposition(source, target) {
+	if (!fs.existsSync(path.join(source, MODULES_DIRECTORY))) return {
+		kind: "skipped",
+		reason: "no-modules"
+	};
+	const found = scan(source);
+	let copied = 0;
+	let linked = 0;
+	for (const relative of found.modules) {
+		const destination = path.join(target, relative);
+		if (fs.existsSync(destination)) continue;
+		try {
+			fs.mkdirSync(path.dirname(destination), { recursive: true });
+			fs.symlinkSync(path.join(source, relative), destination, "dir");
+			linked += 1;
+		} catch {}
+	}
+	for (const relative of found.outputs) {
+		const destination = path.join(target, relative);
+		if (fs.existsSync(destination)) continue;
+		try {
+			fs.mkdirSync(path.dirname(destination), { recursive: true });
+			fs.cpSync(path.join(source, relative), destination, { recursive: true });
+			copied += 1;
+		} catch {}
+	}
+	return {
+		kind: "mirrored",
+		copied,
+		linked
+	};
+}
+//#endregion
+export { mirrorComposition };
+
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/services/compositionMirror/index.ts"],"sourcesContent":["/**\n * Giving a new worktree the build output its parent checkout already has.\n *\n * DESIGN PATTERNS:\n * - Mirrors, never builds. Everything here is a copy or a symlink of something\n *   the parent checkout already produced, so it costs seconds and cannot fail\n *   the way a package manager or a compiler can.\n * - `node_modules` is linked, `dist` is copied. The module tree is gigabytes\n *   and read-only in practice, so a link is right; build output is small and a\n *   link would send a build run inside the worktree straight into the parent's\n *   directory.\n * - Absent parent output means nothing to do. A repository with no\n *   `node_modules` at its root is either not a JS project or not installed, and\n *   either way this has no opinion about it, so a Rust, Go or Python worktree\n *   pays nothing.\n *\n * WHY THIS EXISTS:\n * A DoomPi session composes the extensions its repository's config names, and\n * this repository names its own workspace packages by relative path. Those\n * packages declare `pi.extensions` under `dist/`, which git does not track, so\n * a fresh worktree resolves none of them and the session dies on start. The\n * parent checkout has already built exactly what the child needs.\n *\n * AVOID:\n * - Recursing into `node_modules`. The scan is bounded and skips it; without\n *   that this walks a gigabyte to find nothing.\n * - Treating a mirror failure as fatal. The worktree is good either way; only\n *   the session's composition is poorer for it.\n */\nimport fs from 'node:fs';\nimport path from 'node:path';\n\n/** Directories that are build output worth copying into a new worktree. */\nconst OUTPUT_DIRECTORY = 'dist';\nconst MODULES_DIRECTORY = 'node_modules';\nconst GIT_DIRECTORY = '.git';\n/**\n * How deep the scan goes.\n *\n * Four levels reaches `layers/<group>/<package>/dist` in this repository's\n * layout, and a workspace that buries a package deeper than that gets a\n * partial mirror rather than a slow one.\n */\nconst MAX_DEPTH = 4;\n\nexport type MirrorOutcome =\n  | { kind: 'skipped'; reason: 'no-modules' }\n  | { kind: 'mirrored'; copied: number; linked: number };\n\ninterface Found {\n  /** Paths relative to the source root. */\n  outputs: string[];\n  modules: string[];\n}\n\nfunction scan(root: string): Found {\n  const found: Found = { outputs: [], modules: [] };\n  const walk = (relative: string, depth: number): void => {\n    let entries: fs.Dirent[];\n    try {\n      entries = fs.readdirSync(path.join(root, relative), { withFileTypes: true });\n    } catch {\n      return;\n    }\n    for (const entry of entries) {\n      if (!entry.isDirectory()) continue;\n      const child = relative === '' ? entry.name : `${relative}/${entry.name}`;\n      if (entry.name === GIT_DIRECTORY) continue;\n      // Both of these are destinations, not places to look inside.\n      if (entry.name === MODULES_DIRECTORY) {\n        found.modules.push(child);\n        continue;\n      }\n      if (entry.name === OUTPUT_DIRECTORY) {\n        found.outputs.push(child);\n        continue;\n      }\n      if (depth < MAX_DEPTH) walk(child, depth + 1);\n    }\n  };\n  walk('', 1);\n  return found;\n}\n\n/**\n * Copies the parent's build output into a worktree and links its modules.\n *\n * Individual failures are counted out rather than thrown: a mirror that lands\n * partly is still better than none, and the caller has a worktree either way.\n */\nexport function mirrorComposition(source: string, target: string): MirrorOutcome {\n  if (!fs.existsSync(path.join(source, MODULES_DIRECTORY))) return { kind: 'skipped', reason: 'no-modules' };\n\n  const found = scan(source);\n  let copied = 0;\n  let linked = 0;\n\n  for (const relative of found.modules) {\n    const destination = path.join(target, relative);\n    if (fs.existsSync(destination)) continue;\n    try {\n      fs.mkdirSync(path.dirname(destination), { recursive: true });\n      fs.symlinkSync(path.join(source, relative), destination, 'dir');\n      linked += 1;\n    } catch {\n      // A link the filesystem refuses costs this package one resolution, not\n      // the worktree.\n    }\n  }\n\n  for (const relative of found.outputs) {\n    const destination = path.join(target, relative);\n    if (fs.existsSync(destination)) continue;\n    try {\n      fs.mkdirSync(path.dirname(destination), { recursive: true });\n      fs.cpSync(path.join(source, relative), destination, { recursive: true });\n      copied += 1;\n    } catch {\n      // Same reasoning as a failed link.\n    }\n  }\n\n  return { kind: 'mirrored', copied, linked };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,MAAM,mBAAmB;AACzB,MAAM,oBAAoB;AAC1B,MAAM,gBAAgB;;;;;;;;AAQtB,MAAM,YAAY;AAYlB,SAAS,KAAK,MAAqB;CACjC,MAAM,QAAe;EAAE,SAAS,CAAC;EAAG,SAAS,CAAC;CAAE;CAChD,MAAM,QAAQ,UAAkB,UAAwB;EACtD,IAAI;EACJ,IAAI;GACF,UAAU,GAAG,YAAY,KAAK,KAAK,MAAM,QAAQ,GAAG,EAAE,eAAe,KAAK,CAAC;EAC7E,QAAQ;GACN;EACF;EACA,KAAK,MAAM,SAAS,SAAS;GAC3B,IAAI,CAAC,MAAM,YAAY,GAAG;GAC1B,MAAM,QAAQ,aAAa,KAAK,MAAM,OAAO,GAAG,SAAS,GAAG,MAAM;GAClE,IAAI,MAAM,SAAS,eAAe;GAElC,IAAI,MAAM,SAAS,mBAAmB;IACpC,MAAM,QAAQ,KAAK,KAAK;IACxB;GACF;GACA,IAAI,MAAM,SAAS,kBAAkB;IACnC,MAAM,QAAQ,KAAK,KAAK;IACxB;GACF;GACA,IAAI,QAAQ,WAAW,KAAK,OAAO,QAAQ,CAAC;EAC9C;CACF;CACA,KAAK,IAAI,CAAC;CACV,OAAO;AACT;;;;;;;AAQA,SAAgB,kBAAkB,QAAgB,QAA+B;CAC/E,IAAI,CAAC,GAAG,WAAW,KAAK,KAAK,QAAQ,iBAAiB,CAAC,GAAG,OAAO;EAAE,MAAM;EAAW,QAAQ;CAAa;CAEzG,MAAM,QAAQ,KAAK,MAAM;CACzB,IAAI,SAAS;CACb,IAAI,SAAS;CAEb,KAAK,MAAM,YAAY,MAAM,SAAS;EACpC,MAAM,cAAc,KAAK,KAAK,QAAQ,QAAQ;EAC9C,IAAI,GAAG,WAAW,WAAW,GAAG;EAChC,IAAI;GACF,GAAG,UAAU,KAAK,QAAQ,WAAW,GAAG,EAAE,WAAW,KAAK,CAAC;GAC3D,GAAG,YAAY,KAAK,KAAK,QAAQ,QAAQ,GAAG,aAAa,KAAK;GAC9D,UAAU;EACZ,QAAQ,CAGR;CACF;CAEA,KAAK,MAAM,YAAY,MAAM,SAAS;EACpC,MAAM,cAAc,KAAK,KAAK,QAAQ,QAAQ;EAC9C,IAAI,GAAG,WAAW,WAAW,GAAG;EAChC,IAAI;GACF,GAAG,UAAU,KAAK,QAAQ,WAAW,GAAG,EAAE,WAAW,KAAK,CAAC;GAC3D,GAAG,OAAO,KAAK,KAAK,QAAQ,QAAQ,GAAG,aAAa,EAAE,WAAW,KAAK,CAAC;GACvE,UAAU;EACZ,QAAQ,CAER;CACF;CAEA,OAAO;EAAE,MAAM;EAAY;EAAQ;CAAO;AAC5C"}

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

@@ -0,0 +1,29 @@
+//#region src/services/errors/index.ts
+var DoomGitExpectedError = class extends Error {
+	code;
+	retryable;
+	recovery;
+	constructor(code, message, retryable, recovery) {
+		super(`[${code}] ${message}\nRecovery: ${recovery}`);
+		this.code = code;
+		this.retryable = retryable;
+		this.recovery = recovery;
+		this.name = "DoomGitExpectedError";
+	}
+};
+/** Raised when a worktree action needs the canonical hub but it is not injected. */
+var HubUnavailableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "HubUnavailableError";
+	}
+};
+function invalidRequest(message, recovery) {
+	return new DoomGitExpectedError("invalid_request", message, false, recovery);
+}
+//#endregion
+exports.DoomGitExpectedError = DoomGitExpectedError;
+exports.HubUnavailableError = HubUnavailableError;
+exports.invalidRequest = invalidRequest;
+
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../../src/services/errors/index.ts"],"sourcesContent":["/**\n * Expected failures, kept private to this package.\n *\n * `@agimon-ai/doompi-core` does not export `invalidRequest` or\n * an expected-error base, so this mirrors doompi-team's shape rather than\n * reaching across a layer boundary for it. The duplication is deliberate and\n * small; a shared helper would be the better answer only once a third package\n * needs one.\n */\n\nexport type DoomGitErrorCode =\n  | 'invalid_request'\n  | 'not_a_repository'\n  | 'worktree_exists'\n  | 'worktree_not_found'\n  | 'worktree_not_owned'\n  | 'worktree_peer_unavailable'\n  | 'worktree_dirty'\n  | 'hub_unavailable'\n  | 'spawn_cancelled'\n  | 'registry_write_failed'\n  | 'message_too_large'\n  | 'git_failed';\n\nexport class DoomGitExpectedError extends Error {\n  constructor(\n    readonly code: DoomGitErrorCode,\n    message: string,\n    readonly retryable: boolean,\n    readonly recovery: string,\n  ) {\n    // The recovery line rides in the message because a tool result is read as\n    // text: an error the model cannot act on costs a turn to rediscover.\n    super(`[${code}] ${message}\\nRecovery: ${recovery}`);\n    this.name = 'DoomGitExpectedError';\n  }\n}\n\n/** Raised when a worktree action needs the canonical hub but it is not injected. */\nexport class HubUnavailableError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'HubUnavailableError';\n  }\n}\n\nexport function invalidRequest(message: string, recovery: string): DoomGitExpectedError {\n  return new DoomGitExpectedError('invalid_request', message, false, recovery);\n}\n"],"mappings":";AAwBA,IAAa,uBAAb,cAA0C,MAAM;CAEnC;CAEA;CACA;CAJX,YACE,MACA,SACA,WACA,UACA;EAGA,MAAM,IAAI,KAAK,IAAI,QAAQ,cAAc,UAAU;EAP1C,KAAA,OAAA;EAEA,KAAA,YAAA;EACA,KAAA,WAAA;EAKT,KAAK,OAAO;CACd;AACF;;AAGA,IAAa,sBAAb,cAAyC,MAAM;CAC7C,YAAY,SAAiB;EAC3B,MAAM,OAAO;EACb,KAAK,OAAO;CACd;AACF;AAEA,SAAgB,eAAe,SAAiB,UAAwC;CACtF,OAAO,IAAI,qBAAqB,mBAAmB,SAAS,OAAO,QAAQ;AAC7E"}

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

@@ -0,0 +1,27 @@
+//#region src/services/errors/index.ts
+var DoomGitExpectedError = class extends Error {
+	code;
+	retryable;
+	recovery;
+	constructor(code, message, retryable, recovery) {
+		super(`[${code}] ${message}\nRecovery: ${recovery}`);
+		this.code = code;
+		this.retryable = retryable;
+		this.recovery = recovery;
+		this.name = "DoomGitExpectedError";
+	}
+};
+/** Raised when a worktree action needs the canonical hub but it is not injected. */
+var HubUnavailableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "HubUnavailableError";
+	}
+};
+function invalidRequest(message, recovery) {
+	return new DoomGitExpectedError("invalid_request", message, false, recovery);
+}
+//#endregion
+export { DoomGitExpectedError, HubUnavailableError, invalidRequest };
+
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/services/errors/index.ts"],"sourcesContent":["/**\n * Expected failures, kept private to this package.\n *\n * `@agimon-ai/doompi-core` does not export `invalidRequest` or\n * an expected-error base, so this mirrors doompi-team's shape rather than\n * reaching across a layer boundary for it. The duplication is deliberate and\n * small; a shared helper would be the better answer only once a third package\n * needs one.\n */\n\nexport type DoomGitErrorCode =\n  | 'invalid_request'\n  | 'not_a_repository'\n  | 'worktree_exists'\n  | 'worktree_not_found'\n  | 'worktree_not_owned'\n  | 'worktree_peer_unavailable'\n  | 'worktree_dirty'\n  | 'hub_unavailable'\n  | 'spawn_cancelled'\n  | 'registry_write_failed'\n  | 'message_too_large'\n  | 'git_failed';\n\nexport class DoomGitExpectedError extends Error {\n  constructor(\n    readonly code: DoomGitErrorCode,\n    message: string,\n    readonly retryable: boolean,\n    readonly recovery: string,\n  ) {\n    // The recovery line rides in the message because a tool result is read as\n    // text: an error the model cannot act on costs a turn to rediscover.\n    super(`[${code}] ${message}\\nRecovery: ${recovery}`);\n    this.name = 'DoomGitExpectedError';\n  }\n}\n\n/** Raised when a worktree action needs the canonical hub but it is not injected. */\nexport class HubUnavailableError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'HubUnavailableError';\n  }\n}\n\nexport function invalidRequest(message: string, recovery: string): DoomGitExpectedError {\n  return new DoomGitExpectedError('invalid_request', message, false, recovery);\n}\n"],"mappings":";AAwBA,IAAa,uBAAb,cAA0C,MAAM;CAEnC;CAEA;CACA;CAJX,YACE,MACA,SACA,WACA,UACA;EAGA,MAAM,IAAI,KAAK,IAAI,QAAQ,cAAc,UAAU;EAP1C,KAAA,OAAA;EAEA,KAAA,YAAA;EACA,KAAA,WAAA;EAKT,KAAK,OAAO;CACd;AACF;;AAGA,IAAa,sBAAb,cAAyC,MAAM;CAC7C,YAAY,SAAiB;EAC3B,MAAM,OAAO;EACb,KAAK,OAAO;CACd;AACF;AAEA,SAAgB,eAAe,SAAiB,UAAwC;CACtF,OAAO,IAAI,qBAAqB,mBAAmB,SAAS,OAAO,QAAQ;AAC7E"}

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

@@ -0,0 +1,13 @@
+//#region src/services/extensionService/index.ts
+var DefaultGitExtensionService = class {
+	async execute() {
+		return {
+			message: "Show git worktrees owned by this session",
+			level: "info"
+		};
+	}
+};
+//#endregion
+exports.DefaultGitExtensionService = DefaultGitExtensionService;
+
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../../src/services/extensionService/index.ts"],"sourcesContent":["// @scaffold-generated\nimport type { GitExtensionResult, GitExtensionService } from '../../types/extension';\n\nexport class DefaultGitExtensionService implements GitExtensionService {\n  async execute(): Promise<GitExtensionResult> {\n    return { message: 'Show git worktrees owned by this session', level: 'info' };\n  }\n}\n"],"mappings":";AAGA,IAAa,6BAAb,MAAuE;CACrE,MAAM,UAAuC;EAC3C,OAAO;GAAE,SAAS;GAA4C,OAAO;EAAO;CAC9E;AACF"}

package/dist/{services → src/services}/extensionService/index.d.cts

@@ -1,8 +1,7 @@
 import { GitExtensionResult, GitExtensionService } from "../../types/extension.cjs";
 //#region src/services/extensionService/index.d.ts
-declare class DefaultGitExtensionService implements GitExtensionService {
+export declare class DefaultGitExtensionService implements GitExtensionService {
   execute(): Promise<GitExtensionResult>;
 }
 //#endregion
-export { DefaultGitExtensionService };
 //# sourceMappingURL=index.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../../src/services/extensionService/index.ts"],"mappings":";;qBAGa,sCAAsC;EAC3C,WAAW,QAAQ"}

package/dist/{services → src/services}/extensionService/index.d.mts

@@ -1,8 +1,7 @@
 import { GitExtensionResult, GitExtensionService } from "../../types/extension.mjs";
 //#region src/services/extensionService/index.d.ts
-declare class DefaultGitExtensionService implements GitExtensionService {
+export declare class DefaultGitExtensionService implements GitExtensionService {
   execute(): Promise<GitExtensionResult>;
 }
 //#endregion
-export { DefaultGitExtensionService };
 //# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../../src/services/extensionService/index.ts"],"mappings":";;qBAGa,sCAAsC;EAC3C,WAAW,QAAQ"}

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

@@ -0,0 +1,13 @@
+//#region src/services/extensionService/index.ts
+var DefaultGitExtensionService = class {
+	async execute() {
+		return {
+			message: "Show git worktrees owned by this session",
+			level: "info"
+		};
+	}
+};
+//#endregion
+export { DefaultGitExtensionService };
+
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/services/extensionService/index.ts"],"sourcesContent":["// @scaffold-generated\nimport type { GitExtensionResult, GitExtensionService } from '../../types/extension';\n\nexport class DefaultGitExtensionService implements GitExtensionService {\n  async execute(): Promise<GitExtensionResult> {\n    return { message: 'Show git worktrees owned by this session', level: 'info' };\n  }\n}\n"],"mappings":";AAGA,IAAa,6BAAb,MAAuE;CACrE,MAAM,UAAuC;EAC3C,OAAO;GAAE,SAAS;GAA4C,OAAO;EAAO;CAC9E;AACF"}

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

@@ -0,0 +1,144 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+let node_child_process = require("node:child_process");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+//#region src/services/gitCli/index.ts
+/**
+* Git, as this package needs it.
+*
+* The timeouts are not uniform because the operations are not comparable. A
+* read answers in milliseconds; `worktree add` copies an entire checkout and
+* `worktree remove` deletes one, both bounded by the filesystem rather than by
+* git, and both minutes rather than seconds on a large repository or on
+* Windows. A single timeout would either fail honest work or hang on a wedged
+* one.
+*/
+const READ_TIMEOUT_MS = 3e4;
+const ADD_TIMEOUT_MS = 3e5;
+const REMOVE_TIMEOUT_MS = 3e5;
+const PRUNE_TIMEOUT_MS = 15e3;
+const MAX_OUTPUT_BYTES = 1e6;
+/**
+* Runs git and reports the outcome without ever throwing on a non-zero exit.
+*
+* LC_ALL is pinned because two callers below decide what to do by matching
+* git's own wording, and a translated message would silently turn a recognised
+* condition into an unrecognised failure.
+*/
+function git(cwd, args, timeout) {
+	return new Promise((resolve) => {
+		(0, node_child_process.execFile)("git", [...args], {
+			cwd,
+			timeout,
+			maxBuffer: MAX_OUTPUT_BYTES,
+			env: {
+				...process.env,
+				LC_ALL: "C"
+			}
+		}, (error, stdout, stderr) => {
+			resolve({
+				code: error && typeof error.code === "number" ? error.code : error ? 1 : 0,
+				stdout: String(stdout),
+				stderr: String(stderr)
+			});
+		});
+	});
+}
+/**
+* The message a failed git call is allowed to surface.
+*
+* Raw stderr never travels: it can carry a remote URL with a token in it, and
+* this text ends up in a tool result the model reads and may repeat.
+*/
+function failure(operation, result) {
+	return /* @__PURE__ */ new Error(`git ${operation} failed (exit ${String(result.code)}, ${String(result.stderr.length)} bytes of stderr)`);
+}
+/** Git's own words for "that worktree is not there any more". */
+function missingWorktree(stderr) {
+	const normalized = stderr.toLowerCase();
+	return normalized.includes("is not a working tree") || normalized.includes("cannot remove working tree");
+}
+function createWorktreeGit() {
+	const prune = async (repositoryRoot) => {
+		await git(repositoryRoot, ["worktree", "prune"], PRUNE_TIMEOUT_MS);
+	};
+	return {
+		async addWorktree({ repositoryRoot, path, branch, baseRef }) {
+			const result = await git(repositoryRoot, [
+				"worktree",
+				"add",
+				"-b",
+				branch,
+				path,
+				baseRef
+			], ADD_TIMEOUT_MS);
+			if (result.code !== 0) throw failure("worktree add", result);
+		},
+		async removeWorktree({ repositoryRoot, path, force }) {
+			const result = await git(repositoryRoot, [
+				"worktree",
+				"remove",
+				...force ? ["--force"] : [],
+				path
+			], REMOVE_TIMEOUT_MS);
+			if (result.code === 0) return;
+			if (missingWorktree(result.stderr) && !node_fs.default.existsSync(path)) {
+				await prune(repositoryRoot);
+				return;
+			}
+			throw failure("worktree remove", result);
+		},
+		async deleteBranch({ repositoryRoot, branch }) {
+			return (await git(repositoryRoot, [
+				"branch",
+				"-d",
+				branch
+			], READ_TIMEOUT_MS)).code === 0;
+		},
+		pruneWorktrees: prune,
+		async listWorktreePaths(repositoryRoot) {
+			const result = await git(repositoryRoot, [
+				"worktree",
+				"list",
+				"--porcelain"
+			], READ_TIMEOUT_MS);
+			if (result.code !== 0) return [];
+			return result.stdout.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice(9).trim()).filter((line) => line !== "");
+		},
+		async dirtyFiles(path) {
+			const result = await git(path, ["status", "--porcelain"], READ_TIMEOUT_MS);
+			if (result.code !== 0) return [];
+			return result.stdout.split("\n").map((line) => line.slice(3).trim()).filter((line) => line !== "");
+		},
+		async repositoryRoot(cwd) {
+			const result = await git(cwd, ["rev-parse", "--show-toplevel"], READ_TIMEOUT_MS);
+			if (result.code !== 0) return void 0;
+			const root = result.stdout.trim();
+			return root === "" ? void 0 : root;
+		},
+		async currentBranch(cwd) {
+			const result = await git(cwd, [
+				"rev-parse",
+				"--abbrev-ref",
+				"HEAD"
+			], READ_TIMEOUT_MS);
+			if (result.code !== 0) return void 0;
+			const branch = result.stdout.trim();
+			return branch === "" ? void 0 : branch;
+		},
+		async mergeBranch({ repositoryRoot, branch, message }) {
+			const result = await git(repositoryRoot, [
+				"merge",
+				"--no-ff",
+				...message === void 0 ? [] : ["-m", message],
+				branch
+			], READ_TIMEOUT_MS);
+			if (result.code === 0) return;
+			throw failure("merge", result);
+		}
+	};
+}
+//#endregion
+exports.createWorktreeGit = createWorktreeGit;
+
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["fs"],"sources":["../../../../src/services/gitCli/index.ts"],"sourcesContent":["import { execFile } from 'node:child_process';\nimport fs from 'node:fs';\n\nimport type { WorktreeGit } from '../../types/worktreeRegistry';\n\n/**\n * Git, as this package needs it.\n *\n * The timeouts are not uniform because the operations are not comparable. A\n * read answers in milliseconds; `worktree add` copies an entire checkout and\n * `worktree remove` deletes one, both bounded by the filesystem rather than by\n * git, and both minutes rather than seconds on a large repository or on\n * Windows. A single timeout would either fail honest work or hang on a wedged\n * one.\n */\nconst READ_TIMEOUT_MS = 30_000;\nconst ADD_TIMEOUT_MS = 300_000;\nconst REMOVE_TIMEOUT_MS = 300_000;\nconst PRUNE_TIMEOUT_MS = 15_000;\nconst MAX_OUTPUT_BYTES = 1_000_000;\n\ninterface GitResult {\n  code: number;\n  stdout: string;\n  stderr: string;\n}\n\n/**\n * Runs git and reports the outcome without ever throwing on a non-zero exit.\n *\n * LC_ALL is pinned because two callers below decide what to do by matching\n * git's own wording, and a translated message would silently turn a recognised\n * condition into an unrecognised failure.\n */\nfunction git(cwd: string, args: readonly string[], timeout: number): Promise<GitResult> {\n  return new Promise((resolve) => {\n    execFile(\n      'git',\n      [...args],\n      { cwd, timeout, maxBuffer: MAX_OUTPUT_BYTES, env: { ...process.env, LC_ALL: 'C' } },\n      (error, stdout, stderr) => {\n        const code = error && typeof error.code === 'number' ? error.code : error ? 1 : 0;\n        resolve({ code, stdout: String(stdout), stderr: String(stderr) });\n      },\n    );\n  });\n}\n\n/**\n * The message a failed git call is allowed to surface.\n *\n * Raw stderr never travels: it can carry a remote URL with a token in it, and\n * this text ends up in a tool result the model reads and may repeat.\n */\nfunction failure(operation: string, result: GitResult): Error {\n  return new Error(\n    `git ${operation} failed (exit ${String(result.code)}, ${String(result.stderr.length)} bytes of stderr)`,\n  );\n}\n\n/** Git's own words for \"that worktree is not there any more\". */\nfunction missingWorktree(stderr: string): boolean {\n  const normalized = stderr.toLowerCase();\n  return normalized.includes('is not a working tree') || normalized.includes('cannot remove working tree');\n}\n\nexport function createWorktreeGit(): WorktreeGit {\n  const prune = async (repositoryRoot: string): Promise<void> => {\n    await git(repositoryRoot, ['worktree', 'prune'], PRUNE_TIMEOUT_MS);\n  };\n\n  return {\n    async addWorktree({ repositoryRoot, path, branch, baseRef }) {\n      const result = await git(repositoryRoot, ['worktree', 'add', '-b', branch, path, baseRef], ADD_TIMEOUT_MS);\n      if (result.code !== 0) throw failure('worktree add', result);\n    },\n\n    async removeWorktree({ repositoryRoot, path, force }) {\n      const args = ['worktree', 'remove', ...(force ? ['--force'] : []), path];\n      const result = await git(repositoryRoot, args, REMOVE_TIMEOUT_MS);\n      if (result.code === 0) return;\n      // A directory deleted behind git's back leaves an administrative entry\n      // that makes a later `worktree add` at the same path refuse. Treating\n      // \"already gone\" as success and pruning is what keeps that path reusable,\n      // and it makes remove idempotent for a caller retrying after a crash.\n      if (missingWorktree(result.stderr) && !fs.existsSync(path)) {\n        await prune(repositoryRoot);\n        return;\n      }\n      throw failure('worktree remove', result);\n    },\n\n    async deleteBranch({ repositoryRoot, branch }) {\n      // -d, never -D: git refuses a branch that still holds unmerged commits,\n      // and that refusal is the whole safety property. A rollback that could\n      // throw away work someone committed in the worktree is worse than a\n      // branch left behind.\n      const result = await git(repositoryRoot, ['branch', '-d', branch], READ_TIMEOUT_MS);\n      return result.code === 0;\n    },\n    pruneWorktrees: prune,\n\n    async listWorktreePaths(repositoryRoot) {\n      const result = await git(repositoryRoot, ['worktree', 'list', '--porcelain'], READ_TIMEOUT_MS);\n      if (result.code !== 0) return [];\n      return result.stdout\n        .split('\\n')\n        .filter((line) => line.startsWith('worktree '))\n        .map((line) => line.slice('worktree '.length).trim())\n        .filter((line) => line !== '');\n    },\n\n    async dirtyFiles(path) {\n      const result = await git(path, ['status', '--porcelain'], READ_TIMEOUT_MS);\n      if (result.code !== 0) return [];\n      return result.stdout\n        .split('\\n')\n        .map((line) => line.slice(3).trim())\n        .filter((line) => line !== '');\n    },\n\n    async repositoryRoot(cwd) {\n      const result = await git(cwd, ['rev-parse', '--show-toplevel'], READ_TIMEOUT_MS);\n      if (result.code !== 0) return undefined;\n      const root = result.stdout.trim();\n      return root === '' ? undefined : root;\n    },\n\n    async currentBranch(cwd) {\n      const result = await git(cwd, ['rev-parse', '--abbrev-ref', 'HEAD'], READ_TIMEOUT_MS);\n      if (result.code !== 0) return undefined;\n      const branch = result.stdout.trim();\n      return branch === '' ? undefined : branch;\n    },\n\n    async mergeBranch({ repositoryRoot, branch, message }) {\n      // --no-ff so the worktree's work stays identifiable as a unit after the\n      // fact. A fast-forward would erase the fact that it was ever separate,\n      // which is the one thing worth keeping about a worktree.\n      const args = ['merge', '--no-ff', ...(message === undefined ? [] : ['-m', message]), branch];\n      const result = await git(repositoryRoot, args, READ_TIMEOUT_MS);\n      if (result.code === 0) return;\n      // A conflicted merge leaves the parent mid-merge, which is a state the\n      // person has to resolve; aborting for them would throw away the conflict\n      // markers they need to see.\n      throw failure('merge', result);\n    },\n  };\n}\n"],"mappings":"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"}