@oisincoveney/pipeline 3.20.1 → 3.21.0

package/dist/cli/bootstrap-commands.js

@@ -10,7 +10,7 @@ function registerBootstrapCommands(program) {
 		console.log(flags.json ? JSON.stringify(result) : formatDoctorResult(result));
 		if (!result.passed) throw new Error("Doctor checks failed.");
 	});
-	program.command("init").description("Install or refresh package-owned pipeline support: per-machine harness (skills + slash-command adapters + agent hooks + global instruction files) installed globally to ~/.claude, ~/.config/opencode, ~/.codex with no repo-local config").option("--check", "verify the generated harness is current; fail if stale").option("--dry-run", "show planned changes without writing files").option("--force", "overwrite manually edited harness files").action(async (flags) => {
+	program.command("init").description("Install or refresh moka's slash-command adapters (/moka-execute, /moka-inspect, /moka-quick) plus the singleton MCP gateway host config, globally to ~/.claude, ~/.config/opencode, ~/.codex with no repo-local config. The agent harness (skills, hooks, instruction rules) is provisioned separately from oisin-ee/agent via chezmoi, not by moka.").option("--check", "verify the installed adapters are current; fail if stale").option("--dry-run", "show planned changes without writing files").option("--force", "overwrite manually edited command adapter files").action(async (flags) => {
 		const result = await initPipelineProject({
 			...flags,
 			cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd()

package/dist/pipeline-init.js

@@ -1,102 +1,21 @@
-import { claudeGlobalConfigDir, codexGlobalConfigDir, opencodeGlobalConfigDir } from "./install-commands/shared.js";
-import { AGENT_SKILL_SOURCE } from "./agent-assets.js";
 import { installCommands } from "./install-commands.js";
-import { installHooks } from "./install-hooks.js";
-import { installRules } from "./install-rules.js";
-import { execa } from "execa";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { rm } from "node:fs/promises";
 //#region src/pipeline-init.ts
-const DEFAULT_SKILL_INSTALL_SOURCE = AGENT_SKILL_SOURCE;
-const SKILL_INSTALL_AGENT_ARGS = [
-	"--agent",
-	"opencode",
-	"--agent",
-	"codex",
-	"--agent",
-	"claude-code",
-	"--skill",
-	"*",
-	"--yes",
-	"--global"
-];
 /**
-* Every global location the `skills` CLI writes into for the three agents we
-* manage. The CLI copies each skill's real folder once into the shared master
-* store `~/.agents/skills` and points each agent's global skills dir at it via
-* symlinks, recording install state in `~/.agents/.skill-lock.json` (or
-* `$XDG_STATE_HOME/skills/.skill-lock.json`). Each entry below mirrors that
-* resolution from the skills CLI source (skills `dist/cli.mjs`): per-agent
-* config dirs honor `CLAUDE_CONFIG_DIR` / `CODEX_HOME` /
-* `OPENCODE_CONFIG_DIR`+`XDG_CONFIG_HOME` (reused from install-commands so the
-* test suite's env redirect isolates them), the master store and lock honor
-* the home dir and `XDG_STATE_HOME`.
+* `moka init` installs only moka's own slash-command adapters
+* (`/moka-execute|inspect|quick`) plus the singleton MCP gateway host config,
+* globally for Claude Code, Codex, and OpenCode. The shared agent harness
+* (skills, agent hooks, and global instruction rules) is no longer installed by
+* moka — it is provisioned from `oisin-ee/agent` via chezmoi (the dotfiles'
+* `.chezmoiexternal` clone + `run_onchange` harness installer). Keeping moka's
+* command adapters here means the runner image (and local dev) still gets the
+* `/moka-*` entrypoints after `chezmoi apply` lays down the harness.
 */
-function globalSkillCleanTargets() {
-	const agentsHome = homedir();
-	const skillLockPath = process.env.XDG_STATE_HOME ? join(process.env.XDG_STATE_HOME, "skills", ".skill-lock.json") : join(agentsHome, ".agents", ".skill-lock.json");
-	return [
-		join(claudeGlobalConfigDir(), "skills"),
-		join(codexGlobalConfigDir(), "skills"),
-		join(opencodeGlobalConfigDir(), "skills"),
-		join(agentsHome, ".agents", "skills"),
-		skillLockPath
-	];
-}
-/**
-* Clean-replace step run before the additive `skills add`. `npx skills add`
-* only ever adds, so without this a renamed, removed, or foreign global skill
-* accumulates forever across `moka init` runs. Removing the per-agent symlink
-* farms + shared master store + lock resets global skill state so the post-add
-* set equals exactly the canonical `oisin-ee/agent` source. Safe when absent
-* (rm force); only `skills` subdirs, the master store, and the lock are
-* touched — never a whole host config dir.
-*/
-async function cleanGlobalSkills() {
-	await Promise.all(globalSkillCleanTargets().map((target) => rm(target, {
-		force: true,
-		recursive: true
-	})));
-}
-async function installDefaultSkills(cwd) {
-	try {
-		await cleanGlobalSkills();
-		await execa("npx", [
-			"--yes",
-			"skills",
-			"add",
-			DEFAULT_SKILL_INSTALL_SOURCE,
-			...SKILL_INSTALL_AGENT_ARGS
-		], {
-			cwd,
-			stdio: "inherit"
-		});
-	} catch (error) {
-		const cause = error instanceof Error ? `: ${error.message}` : "";
-		throw new Error(`Failed to install default skills from ${DEFAULT_SKILL_INSTALL_SOURCE}${cause}. If this is a private repository, authenticate GitHub access for npx skills add and rerun \`moka init\`.`);
-	}
-}
-function hookInstallerFiles(result) {
-	return "items" in result ? result.items.map((item) => item.path) : result.files;
-}
 async function initPipelineProject(options = {}) {
-	const cwd = options.cwd ?? process.cwd();
-	const { check, dryRun } = options;
-	const installerFlags = initInstallerFlags(options);
-	if (!(check || dryRun)) await (options.skillInstaller ?? installDefaultSkills)(cwd);
-	const result = await installCommands({
-		cwd,
+	return { files: (await installCommands({
+		cwd: options.cwd ?? process.cwd(),
 		host: "all",
-		...installerFlags
-	});
-	const hooks = await (options.hookInstaller ?? (() => installHooks(installerFlags)))(cwd);
-	const rulesResult = await (options.rulesInstaller ?? (() => installRules(installerFlags)))(cwd);
-	return { files: [
-		...result.items.map((item) => item.path),
-		...hookInstallerFiles(hooks),
-		...rulesResult.items.map((item) => item.path)
-	] };
+		...initInstallerFlags(options)
+	})).items.map((item) => item.path) };
 }
 function initInstallerFlags(options) {
 	const { check, dryRun } = options;
@@ -108,17 +27,17 @@ function initInstallerFlags(options) {
 }
 const INIT_RESULT_COPY = {
 	install: {
-		headline: "Initialized package-owned pipeline support:",
+		headline: "Initialized moka slash-command adapters:",
 		fileVerb: "generated",
 		footer: "no repo-local pipeline config files were created"
 	},
 	check: {
-		headline: "Verified package-owned pipeline support is current:",
+		headline: "Verified moka slash-command adapters are current:",
 		fileVerb: "current",
-		footer: "harness verified; no changes written"
+		footer: "adapters verified; no changes written"
 	},
 	dryRun: {
-		headline: "Planned package-owned pipeline support:",
+		headline: "Planned moka slash-command adapters:",
 		fileVerb: "would generate",
 		footer: "dry run; no changes written"
 	}
@@ -132,7 +51,7 @@ function formatPipelineInitResult(result, mode = {}) {
 	const copy = INIT_RESULT_COPY[initResultMode(mode)];
 	return [
 		copy.headline,
-		"per-machine harness globally (user/global skills + ~/.claude, ~/.config/opencode, ~/.codex); global instruction files generated via rulesync from oisin-ee/agent/rules; inherited by every repo with no per-repo copy",
+		"per-machine slash-command adapters (/moka-execute|inspect|quick) installed globally (~/.claude, ~/.config/opencode, ~/.codex); the agent harness (skills, hooks, instruction rules) comes from oisin-ee/agent via chezmoi, not moka",
 		...result.files.map((path) => `${copy.fileVerb} ${path}`),
 		copy.footer
 	].join("\n");

package/package.json

@@ -138,7 +138,7 @@
     "prepack": "nub run build:cli"
   },
   "type": "module",
-  "version": "3.20.1",
+  "version": "3.21.0",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/agent-assets.js

@@ -1,7 +0,0 @@
-//#region src/agent-assets.ts
-const AGENT_ASSET_SOURCE = "oisin-ee/agent";
-const AGENT_SKILL_SOURCE = "oisin-ee/agent/skills";
-const AGENT_HOOKS_DIR = "hooks";
-const AGENT_RULES_DIR = "rules";
-//#endregion
-export { AGENT_ASSET_SOURCE, AGENT_HOOKS_DIR, AGENT_RULES_DIR, AGENT_SKILL_SOURCE };

package/dist/install-hooks.js

@@ -1,274 +0,0 @@
-import { applyJsonEdit, ensureTrailingNewline, parseJsonRecord } from "./json-config-merge.js";
-import { resolveHarnessTarget } from "./install-commands/shared.js";
-import { AGENT_ASSET_SOURCE, AGENT_HOOKS_DIR } from "./agent-assets.js";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { execa } from "execa";
-import { tmpdir } from "node:os";
-import { dirname, join, relative } from "node:path";
-import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
-import { createHash } from "node:crypto";
-//#region src/install-hooks.ts
-const DEFAULT_HOOK_INSTALL_SOURCE = AGENT_ASSET_SOURCE;
-const HOOK_HOSTS = [
-	"claude-code",
-	"codex",
-	"opencode"
-];
-const MANIFEST_FILE = ".moka-agent-hooks.json";
-const HOST_TARGET_ROOT = {
-	"claude-code": ".claude",
-	codex: ".codex",
-	opencode: ".opencode"
-};
-const NON_HOOK_OWNED_TARGETS = /* @__PURE__ */ new Set([".opencode/opencode.json"]);
-function hashContent(content) {
-	return createHash("sha256").update(content).digest("hex");
-}
-const MERGE_MANAGED = { ".claude/settings.json": [
-	["hooks"],
-	["skillListingBudgetFraction"],
-	["skillOverrides"]
-] };
-function mergeKeysFor(path) {
-	return MERGE_MANAGED[path];
-}
-function canonicalize(value) {
-	if (Array.isArray(value)) return value.map(canonicalize);
-	if (isRecord(value)) {
-		const out = {};
-		for (const key of Object.keys(value).sort()) out[key] = canonicalize(value[key]);
-		return out;
-	}
-	return value;
-}
-function hashJson(value) {
-	return hashContent(Buffer.from(JSON.stringify(canonicalize(value) ?? null)));
-}
-function managedSubtree(text, keyPath) {
-	const parsed = parseJsonRecord(text);
-	if (!parsed.ok) return;
-	let cursor = parsed.value;
-	for (const key of keyPath) {
-		if (!isRecord(cursor)) return;
-		cursor = cursor[key];
-	}
-	return cursor;
-}
-function targetIdentityHash(path, content) {
-	const mergeKeys = mergeKeysFor(path);
-	if (!mergeKeys) return hashContent(content);
-	const text = content.toString("utf8");
-	const subtrees = {};
-	for (const keyPath of mergeKeys) subtrees[keyPath.join(".")] = managedSubtree(text, keyPath);
-	return hashJson(subtrees);
-}
-async function cloneHookRepository(targetDir) {
-	await execa("gh", [
-		"repo",
-		"clone",
-		DEFAULT_HOOK_INSTALL_SOURCE,
-		targetDir,
-		"--",
-		"--depth=1"
-	], { stdio: "inherit" });
-}
-async function withHookSource(useSource) {
-	const parent = await mkdtemp(join(tmpdir(), "moka-agent-"));
-	const source = join(parent, "agent");
-	try {
-		await cloneHookRepository(source);
-		return await useSource(source);
-	} finally {
-		await rm(parent, {
-			force: true,
-			recursive: true
-		});
-	}
-}
-async function listFiles(root) {
-	if (!existsSync(root)) return [];
-	if (statSync(root).isFile()) return [root];
-	const entries = await readdir(root, { withFileTypes: true });
-	return (await Promise.all(entries.map((entry) => {
-		const path = join(root, entry.name);
-		return entry.isDirectory() ? listFiles(path) : [path];
-	}))).flat();
-}
-async function sourceHookFiles(source) {
-	return (await Promise.all(HOOK_HOSTS.map(async (host) => {
-		const hostRoot = join(source, AGENT_HOOKS_DIR, host);
-		return (await listFiles(hostRoot)).flatMap((file) => {
-			const relativePath = relative(hostRoot, file).replaceAll("\\", "/");
-			const content = readFileSync(file);
-			const path = `${HOST_TARGET_ROOT[host]}/${relativePath}`;
-			return isHookOwnedTarget(path) ? [{
-				content,
-				hash: targetIdentityHash(path, content),
-				host,
-				path
-			}] : [];
-		});
-	}))).flat().sort((a, b) => a.path.localeCompare(b.path));
-}
-function manifestPath(host) {
-	return resolveHarnessTarget(`${HOST_TARGET_ROOT[host]}/${MANIFEST_FILE}`);
-}
-function emptyManifest() {
-	return {
-		files: {},
-		repository: DEFAULT_HOOK_INSTALL_SOURCE,
-		version: 1
-	};
-}
-function isHookOwnedTarget(path) {
-	return !NON_HOOK_OWNED_TARGETS.has(path);
-}
-function readManifest(host) {
-	const path = manifestPath(host);
-	if (!existsSync(path)) return emptyManifest();
-	try {
-		return normalizeManifest(JSON.parse(readFileSync(path, "utf8")));
-	} catch {
-		return emptyManifest();
-	}
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeManifest(value) {
-	const files = {};
-	const manifestFiles = isRecord(value) ? value.files : void 0;
-	if (!isRecord(manifestFiles)) return emptyManifest();
-	for (const [path, entry] of Object.entries(manifestFiles)) if (isRecord(entry) && typeof entry.hash === "string") files[path] = { hash: entry.hash };
-	return {
-		files,
-		repository: DEFAULT_HOOK_INSTALL_SOURCE,
-		version: 1
-	};
-}
-function targetPath(path) {
-	return resolveHarnessTarget(path);
-}
-function actionForFile(file, force, manifests) {
-	const target = targetPath(file.path);
-	if (!existsSync(target)) return "create";
-	const currentHash = targetIdentityHash(file.path, readFileSync(target));
-	if (currentHash === file.hash) return "unchanged";
-	if (force) return "update";
-	return (manifests.get(file.host)?.files[file.path])?.hash === currentHash ? "update" : "conflict";
-}
-function planFiles(files, force, manifests) {
-	return files.map((file) => ({
-		...file,
-		action: actionForFile(file, force, manifests)
-	}));
-}
-function planObsoleteFiles(desiredPaths, force, manifests) {
-	const obsolete = [];
-	for (const [host, manifest] of manifests) for (const [path, entry] of Object.entries(manifest.files)) {
-		const planned = planObsoleteFile(host, path, entry, force, desiredPaths);
-		if (planned) obsolete.push(planned);
-	}
-	return obsolete.sort((a, b) => a.path.localeCompare(b.path));
-}
-function planObsoleteFile(host, path, entry, force, desiredPaths) {
-	if (desiredPaths.has(path) || !isHookOwnedTarget(path)) return;
-	const target = targetPath(path);
-	if (!existsSync(target)) return;
-	const currentHash = hashContent(readFileSync(target));
-	return {
-		action: force || currentHash === entry.hash ? "delete" : "conflict",
-		host,
-		path
-	};
-}
-async function writePlannedFile(file) {
-	if (file.action === "conflict" || file.action === "unchanged") return;
-	const target = targetPath(file.path);
-	await mkdir(dirname(target), { recursive: true });
-	const mergeKeys = mergeKeysFor(file.path);
-	if (mergeKeys && existsSync(target)) {
-		const sourceText = file.content.toString("utf8");
-		let merged = readFileSync(target, "utf8");
-		for (const keyPath of mergeKeys) {
-			const desired = managedSubtree(sourceText, keyPath);
-			if (desired !== void 0) merged = applyJsonEdit(merged, keyPath, desired);
-		}
-		await writeFile(target, ensureTrailingNewline(merged));
-		return;
-	}
-	await writeFile(target, file.content);
-}
-function itemFor(file) {
-	return {
-		action: file.action,
-		host: file.host,
-		path: file.path
-	};
-}
-function itemForObsolete(file) {
-	return {
-		action: file.action,
-		host: file.host,
-		path: file.path
-	};
-}
-async function removeObsoleteFile(file) {
-	if (file.action !== "delete") return;
-	await rm(targetPath(file.path), { force: true });
-}
-function assertNoConflicts(items, dryRun) {
-	if (dryRun) return;
-	const conflicts = items.filter((item) => item.action === "conflict");
-	if (conflicts.length === 0) return;
-	throw new Error([
-		"Refusing to overwrite manually edited hook files.",
-		...conflicts.map((item) => `- ${item.path}`),
-		"Re-run with --force to overwrite them."
-	].join("\n"));
-}
-function assertCheckCurrent(items, check) {
-	if (!check) return;
-	const changed = items.filter((item) => item.action !== "unchanged");
-	if (changed.length === 0) return;
-	throw new Error(["Installed hook files are not up to date.", ...changed.map((item) => `- ${item.path}: ${item.action}`)].join("\n"));
-}
-async function writeManifests(files) {
-	const byHost = /* @__PURE__ */ new Map();
-	for (const host of HOOK_HOSTS) byHost.set(host, emptyManifest());
-	for (const file of files) {
-		const manifest = byHost.get(file.host);
-		if (manifest) manifest.files[file.path] = { hash: file.hash };
-	}
-	await Promise.all([...byHost.entries()].map(async ([host, manifest]) => {
-		const path = manifestPath(host);
-		if (Object.keys(manifest.files).length === 0) {
-			await rm(path, { force: true });
-			return;
-		}
-		await mkdir(dirname(path), { recursive: true });
-		await writeFile(path, `${JSON.stringify(manifest, null, 2)}\n`);
-	}));
-}
-function installHooks(options = {}) {
-	return withHookSource(async (source) => {
-		const files = await sourceHookFiles(source);
-		const manifests = new Map(HOOK_HOSTS.map((host) => [host, readManifest(host)]));
-		const planned = planFiles(files, Boolean(options.force), manifests);
-		const obsolete = planObsoleteFiles(new Set(files.map((file) => file.path)), Boolean(options.force), manifests);
-		const items = [...planned.map(itemFor), ...obsolete.map(itemForObsolete)];
-		assertCheckCurrent(items, Boolean(options.check));
-		assertNoConflicts(items, Boolean(options.dryRun));
-		if (!(options.check || options.dryRun)) {
-			for (const file of planned) await writePlannedFile(file);
-			for (const file of obsolete) await removeObsoleteFile(file);
-			await writeManifests(planned);
-		}
-		return {
-			items,
-			source: DEFAULT_HOOK_INSTALL_SOURCE
-		};
-	});
-}
-//#endregion
-export { installHooks };

package/dist/install-rules.js

@@ -1,200 +0,0 @@
-import { resolveHarnessTarget } from "./install-commands/shared.js";
-import { AGENT_ASSET_SOURCE, AGENT_RULES_DIR } from "./agent-assets.js";
-import { execa } from "execa";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
-//#region src/install-rules.ts
-const DEFAULT_RULES_INSTALL_SOURCE = AGENT_ASSET_SOURCE;
-const RULESYNC_PACKAGE = "rulesync@8.30.1";
-const RULESYNC_TARGETS = [
-	"claudecode",
-	"codexcli",
-	"geminicli",
-	"opencode"
-];
-const RULE_OUTPUTS = [
-	{
-		generatedPath: ".claude/CLAUDE.md",
-		targetPath: ".claude/CLAUDE.md"
-	},
-	{
-		generatedPath: ".codex/AGENTS.md",
-		targetPath: ".codex/AGENTS.md"
-	},
-	{
-		generatedPath: ".gemini/GEMINI.md",
-		targetPath: ".gemini/GEMINI.md"
-	},
-	{
-		generatedPath: ".config/opencode/AGENTS.md",
-		targetPath: ".opencode/AGENTS.md"
-	}
-];
-async function cloneRulesRepository(targetDir) {
-	await execa("gh", [
-		"repo",
-		"clone",
-		DEFAULT_RULES_INSTALL_SOURCE,
-		targetDir,
-		"--",
-		"--depth=1"
-	], { stdio: "inherit" });
-}
-async function withRulesSource(sourceOverride, useSource) {
-	if (sourceOverride !== void 0) return useSource(sourceOverride);
-	const parent = await mkdtemp(join(tmpdir(), "moka-agent-rules-"));
-	const source = join(parent, "agent");
-	try {
-		await cloneRulesRepository(source);
-		return await useSource(source);
-	} finally {
-		await rm(parent, {
-			force: true,
-			recursive: true
-		});
-	}
-}
-async function defaultRulesyncRunner(args, opts) {
-	try {
-		await execa("npx", [
-			"--yes",
-			RULESYNC_PACKAGE,
-			...args
-		], {
-			cwd: opts.cwd,
-			env: opts.env,
-			stdio: "inherit"
-		});
-	} catch (error) {
-		const cause = error instanceof Error ? `: ${error.message}` : "";
-		throw new Error(`Failed to generate global rules from ${DEFAULT_RULES_INSTALL_SOURCE}${cause}. If this is a private repository, authenticate GitHub access with \`gh auth login\` and rerun \`moka init\`.`);
-	}
-}
-async function buildRootRule(source) {
-	const rulesDir = join(source, AGENT_RULES_DIR);
-	let entries = [];
-	try {
-		entries = (await readdir(rulesDir, { withFileTypes: true })).filter((d) => d.isFile() && d.name.endsWith(".md")).map((d) => d.name).sort((a, b) => a.localeCompare(b));
-	} catch {}
-	const rootContent = `---
-root: true
-targets:
-  - "*"
----
-
-${(await Promise.all(entries.map(async (name) => {
-		return (await readFile(join(rulesDir, name), "utf8")).trimEnd();
-	}))).join("\n\n")}\n`;
-	const rulesyncRulesDir = join(source, ".rulesync", "rules");
-	await mkdir(rulesyncRulesDir, { recursive: true });
-	await writeFile(join(rulesyncRulesDir, "_root.md"), rootContent);
-}
-async function withRulesyncHome(useHome) {
-	const home = await mkdtemp(join(tmpdir(), "moka-rules-home-"));
-	try {
-		return await useHome(home);
-	} finally {
-		await rm(home, {
-			force: true,
-			recursive: true
-		});
-	}
-}
-function rulesyncArgs(options) {
-	const args = [
-		"generate",
-		"-t",
-		RULESYNC_TARGETS.join(","),
-		"-f",
-		"rules",
-		"--delete",
-		"--global"
-	];
-	if (options.dryRun) args.push("--dry-run");
-	if (options.silent) args.push("--silent");
-	return args;
-}
-async function runRulesyncGenerate(input) {
-	await input.runner(rulesyncArgs(input), {
-		cwd: input.source,
-		env: {
-			...process.env,
-			HOME_DIR: input.home
-		}
-	});
-}
-function ruleItems(action) {
-	return RULE_OUTPUTS.map((output) => ({
-		action,
-		path: resolveHarnessTarget(output.targetPath)
-	}));
-}
-function readGeneratedRuleFiles(home) {
-	return Promise.all(RULE_OUTPUTS.map(async (output) => ({
-		content: await readFile(join(home, output.generatedPath), "utf8"),
-		path: resolveHarnessTarget(output.targetPath)
-	})));
-}
-async function writeGeneratedRuleFiles(files) {
-	for (const file of files) {
-		await mkdir(dirname(file.path), { recursive: true });
-		await writeFile(file.path, file.content);
-	}
-}
-async function installedRuleAction(file) {
-	try {
-		return await readFile(file.path, "utf8") === file.content ? "unchanged" : "update";
-	} catch {
-		return "create";
-	}
-}
-async function assertInstalledRulesCurrent(files) {
-	const changed = (await Promise.all(files.map(async (file) => ({
-		action: await installedRuleAction(file),
-		path: file.path
-	})))).filter((item) => item.action !== "unchanged");
-	if (changed.length === 0) return;
-	throw new Error(["Installed rule files are not up to date.", ...changed.map((item) => `- ${item.path}: ${item.action}`)].join("\n"));
-}
-function installRules(options = {}) {
-	const runner = options.rulesyncRunner ?? defaultRulesyncRunner;
-	return withRulesSource(options.sourceOverride, async (source) => {
-		await buildRootRule(source);
-		return withRulesyncHome(async (home) => {
-			if (options.dryRun) {
-				await runRulesyncGenerate({
-					dryRun: true,
-					home,
-					runner,
-					source
-				});
-				return {
-					items: ruleItems("skip"),
-					source: DEFAULT_RULES_INSTALL_SOURCE
-				};
-			}
-			await runRulesyncGenerate({
-				home,
-				runner,
-				silent: options.check,
-				source
-			});
-			const files = await readGeneratedRuleFiles(home);
-			if (options.check) {
-				await assertInstalledRulesCurrent(files);
-				return {
-					items: ruleItems("skip"),
-					source: DEFAULT_RULES_INSTALL_SOURCE
-				};
-			}
-			await writeGeneratedRuleFiles(files);
-			return {
-				items: ruleItems("generate"),
-				source: DEFAULT_RULES_INSTALL_SOURCE
-			};
-		});
-	});
-}
-//#endregion
-export { installRules };