@tanstack/intent 0.2.1 → 0.3.1

package/README.md

@@ -122,6 +122,7 @@ The real risk with any derived artifact is staleness. `npx @tanstack/intent@late
 | Command                                            | Description                                         |
 | -------------------------------------------------- | --------------------------------------------------- |
 | `npx @tanstack/intent@latest install`              | Set up skill loading guidance in agent config files |
+| `npx @tanstack/intent@latest hooks install`        | Install hook enforcement for supported agents       |
 | `npx @tanstack/intent@latest list [--json]`        | Discover local intent-enabled packages              |
 | `npx @tanstack/intent@latest load <use>`           | Load `<package>#<skill>` SKILL.md content           |
 | `npx @tanstack/intent@latest meta`                 | List meta-skills for library maintainers            |

package/dist/{artifact-coverage-DFtI6V_H.mjs → artifact-coverage-DerRKsWw.mjs}

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "yaml";
-//#region src/artifact-coverage.ts
+//#region src/staleness/artifact-coverage.ts
 function isRecord(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }

package/dist/artifact-coverage-Dia0ZRPy.mjs

@@ -0,0 +1,2 @@
+import { t as readIntentArtifacts } from "./artifact-coverage-DerRKsWw.mjs";
+export { readIntentArtifacts };

package/dist/{cli-error-DDAO6DIL.mjs → cli-error-BebkXaTJ.mjs}

@@ -1,4 +1,4 @@
-//#region src/cli-error.ts
+//#region src/shared/cli-error.ts
 const CLI_FAILURE = Symbol("CliFailure");
 function fail(message, exitCode = 1) {
 	throw {

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as isCliFailure, t as fail } from "./cli-error-DDAO6DIL.mjs";
+import { n as isCliFailure, t as fail } from "./cli-error-BebkXaTJ.mjs";
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { cac } from "cac";
@@ -7,48 +7,53 @@ import { cac } from "cac";
 function createCli() {
 	const cli = cac("intent");
 	cli.usage("<command> [options]");
-	cli.command("list", "Discover intent-enabled packages from the project or workspace").usage("list [--json] [--debug] [--global] [--global-only] [--no-notices]").option("--json", "Output JSON").option("--debug", "Print discovery debug details to stderr").option("--global", "Include global packages after project packages").option("--global-only", "List global packages only").option("--no-notices", "Suppress non-critical notices on stderr").example("list").example("list --json").example("list --global").action(async (options) => {
-		const { runListCommand } = await import("./list-C-eGocZP.mjs");
+	cli.command("list", "Discover intent-enabled packages from the project or workspace").usage("list [--json] [--debug] [--global] [--global-only] [--show-hidden] [--no-notices]").option("--json", "Output JSON").option("--debug", "Print discovery debug details to stderr").option("--global", "Include global packages after project packages").option("--global-only", "List global packages only").option("--show-hidden", "Show hidden skill sources not listed in intent.skills").option("--no-notices", "Suppress non-critical notices on stderr").example("list").example("list --json").example("list --global").action(async (options) => {
+		const { runListCommand } = await import("./list-DUXFVM5r.mjs");
 		await runListCommand(options);
 	});
 	cli.command("exclude [action] [pattern]", "Manage package.json intent.exclude entries").usage("exclude [list|add|remove] [pattern] [--json]").option("--json", "Output JSON list of configured exclude patterns").example("exclude").example("exclude list --json").example("exclude add @tanstack/router#experimental-*").example("exclude remove @tanstack/router#experimental-*").action(async (action, pattern, options) => {
-		const { runExcludeCommand } = await import("./exclude-DbHwcgQQ.mjs");
+		const { runExcludeCommand } = await import("./exclude-IfSv-XI_.mjs");
 		await runExcludeCommand(action, pattern, options);
 	});
 	cli.command("load [use]", "Load a compact skill use and print its SKILL.md").usage("load <use> [--path] [--json] [--debug] [--global] [--global-only]").option("--path", "Print the resolved skill path instead of file content").option("--json", "Output JSON").option("--debug", "Print resolution debug details to stderr").option("--global", "Load from project packages, then global packages").option("--global-only", "Load from global packages only").example("load @tanstack/query#core").example("load @tanstack/query#core --path").action(async (use, options) => {
-		const { runLoadCommand } = await import("./load-DDNrmeBz.mjs");
+		const { runLoadCommand } = await import("./load-DieqITz5.mjs");
 		await runLoadCommand(use, options);
 	});
 	cli.command("meta [name]", "List meta-skills, or print one by name").usage("meta [name]").example("meta").example("meta domain-discovery").action(async (name) => {
-		const [{ getMetaDir }, { runMetaCommand }] = await Promise.all([import("./cli-support-BANzHEBM.mjs"), import("./meta-CF4XIYOo.mjs")]);
+		const [{ getMetaDir }, { runMetaCommand }] = await Promise.all([import("./support-CDhR09kb.mjs"), import("./meta-Dk7d0N2J.mjs")]);
 		await runMetaCommand(name, getMetaDir());
 	});
 	cli.command("validate [dir]", "Validate skill files").usage("validate [dir] [--github-summary] [--fix] [--check]").option("--github-summary", "Write a GitHub Actions step summary").option("--fix", "Rewrite fixable SKILL.md frontmatter issues").option("--check", "Fail if fixable SKILL.md frontmatter issues would be rewritten").example("validate").example("validate packages/query/skills").action(async (dir, options) => {
-		const { runValidateCommand } = await import("./validate-BAU0uzvQ.mjs");
+		const { runValidateCommand } = await import("./validate-Cm-gfxGX.mjs");
 		await runValidateCommand(dir, options);
 	});
 	cli.command("install", "Create or update skill loading guidance in an agent config file").usage("install [--map] [--dry-run] [--print-prompt] [--global] [--global-only] [--no-notices]").option("--map", "Write explicit skill-to-task mappings").option("--dry-run", "Print the generated block without writing").option("--print-prompt", "Print the legacy agent setup prompt instead of writing").option("--global", "Include global packages after project packages").option("--global-only", "Install mappings from global packages only").option("--no-notices", "Suppress non-critical notices on stderr").example("install").example("install --map").example("install --dry-run").example("install --print-prompt").example("install --global").action(async (options) => {
-		const [{ scanIntentsOrFail }, { runInstallCommand }] = await Promise.all([import("./cli-support-BANzHEBM.mjs"), import("./install-Bv2qdHwd.mjs")]);
+		const [{ scanIntentsOrFail }, { runInstallCommand }] = await Promise.all([import("./support-CDhR09kb.mjs"), import("./command-BMdho_4n.mjs")]);
 		await runInstallCommand(options, scanIntentsOrFail);
 	});
+	cli.command("hooks [action]", "Manage agent hooks that enforce skill loading").usage("hooks install [--scope project|user] [--agents copilot,claude,codex|all]").option("--scope <scope>", "Hook install scope: project or user").option("--agents <agents>", "Hook agents: copilot,claude,codex, or all").example("hooks install").example("hooks install --scope user --agents copilot").action(async (action, options) => {
+		if (action !== "install") fail("Unknown hooks action: expected install.");
+		const { runHooksInstallCommand } = await import("./command-BBzoalDz.mjs");
+		runHooksInstallCommand(options);
+	});
 	cli.command("scaffold", "Print maintainer scaffold prompt").usage("scaffold").action(async () => {
-		const [{ getMetaDir }, { runScaffoldCommand }] = await Promise.all([import("./cli-support-BANzHEBM.mjs"), import("./scaffold-D8TAMXvs.mjs")]);
+		const [{ getMetaDir }, { runScaffoldCommand }] = await Promise.all([import("./support-CDhR09kb.mjs"), import("./scaffold-D8TAMXvs.mjs")]);
 		runScaffoldCommand(getMetaDir());
 	});
 	cli.command("stale [dir]", "Check skills for staleness in the current package or workspace").usage("stale [dir] [--json] [--github-review]").option("--json", "Output JSON").option("--github-review", "Write GitHub Actions review PR files").option("--package-label <label>", "Fallback package label for review PRs").example("stale").example("stale packages/query").example("stale --json").action(async (targetDir, options) => {
-		const [{ resolveStaleTargets }, { runStaleCommand }] = await Promise.all([import("./cli-support-BANzHEBM.mjs"), import("./stale-DhjSTIt-.mjs")]);
+		const [{ resolveStaleTargets }, { runStaleCommand }] = await Promise.all([import("./support-CDhR09kb.mjs"), import("./stale-DlNJHwga.mjs")]);
 		await runStaleCommand(targetDir, options, resolveStaleTargets);
 	});
 	cli.command("edit-package-json", "Update package.json files so skills are published").usage("edit-package-json").action(async () => {
-		const { runEditPackageJsonCommand } = await import("./edit-package-json-D8xfcy2X.mjs");
+		const { runEditPackageJsonCommand } = await import("./edit-package-json-CdnA7_TA.mjs");
 		await runEditPackageJsonCommand(process.cwd());
 	});
 	cli.command("setup", "Copy Intent CI workflow templates into .github/workflows/").usage("setup").action(async () => {
-		const [{ getMetaDir }, { runSetupGithubActionsCommand }] = await Promise.all([import("./cli-support-BANzHEBM.mjs"), import("./setup-github-actions-IxZTZihi.mjs")]);
+		const [{ getMetaDir }, { runSetupGithubActionsCommand }] = await Promise.all([import("./support-CDhR09kb.mjs"), import("./github-actions-D41VZqWh.mjs")]);
 		await runSetupGithubActionsCommand(process.cwd(), getMetaDir());
 	});
 	cli.command("setup-github-actions", "Copy Intent CI workflow templates into .github/workflows/").usage("setup-github-actions").action(async () => {
-		const [{ getMetaDir }, { runSetupGithubActionsCommand }] = await Promise.all([import("./cli-support-BANzHEBM.mjs"), import("./setup-github-actions-IxZTZihi.mjs")]);
+		const [{ getMetaDir }, { runSetupGithubActionsCommand }] = await Promise.all([import("./support-CDhR09kb.mjs"), import("./github-actions-D41VZqWh.mjs")]);
 		await runSetupGithubActionsCommand(process.cwd(), getMetaDir());
 	});
 	cli.command("help [command]", "Display help for a command").action((commandName) => {

package/dist/command-BBzoalDz.mjs

@@ -0,0 +1,388 @@
+import { t as fail } from "./cli-error-BebkXaTJ.mjs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { homedir } from "node:os";
+//#region src/hooks/adapters.ts
+const HOOK_SCRIPT_DIR = ".intent/hooks";
+const HOOK_AGENT_ADAPTERS = {
+	claude: {
+		agent: "claude",
+		configKind: "claude-settings",
+		supportedScopes: new Set(["project", "user"]),
+		paths: (scope, { homeDir, root }) => {
+			const project = scope === "project";
+			return {
+				configPath: project ? join(root, ".claude", "settings.json") : join(homeDir, ".claude", "settings.json"),
+				scriptPath: project ? join(root, HOOK_SCRIPT_DIR, "intent-claude-gate.mjs") : join(homeDir, ".tanstack", "intent", "hooks", "intent-claude-gate.mjs")
+			};
+		}
+	},
+	codex: {
+		agent: "codex",
+		configKind: "codex-hooks",
+		supportedScopes: new Set(["project", "user"]),
+		paths: (scope, { homeDir, root }) => {
+			const project = scope === "project";
+			return {
+				configPath: project ? join(root, ".codex", "hooks.json") : join(homeDir, ".codex", "hooks.json"),
+				scriptPath: project ? join(root, HOOK_SCRIPT_DIR, "intent-codex-gate.mjs") : join(homeDir, ".tanstack", "intent", "hooks", "intent-codex-gate.mjs")
+			};
+		}
+	},
+	copilot: {
+		agent: "copilot",
+		configKind: "copilot-hooks",
+		supportedScopes: new Set(["user"]),
+		paths: (_scope, { copilotHome, homeDir }) => ({
+			configPath: join(copilotHome ?? join(homeDir, ".copilot"), "hooks", "hooks.json"),
+			scriptPath: join(homeDir, ".tanstack", "intent", "hooks", "intent-copilot-gate.mjs")
+		})
+	}
+};
+const ALL_HOOK_AGENTS = [
+	"copilot",
+	"claude",
+	"codex"
+];
+//#endregion
+//#region src/hooks/policy.ts
+const EDIT_TOOLS_BY_AGENT = {
+	claude: new Set([
+		"Write",
+		"Edit",
+		"MultiEdit",
+		"NotebookEdit"
+	]),
+	codex: new Set([
+		"apply_patch",
+		"Write",
+		"Edit"
+	]),
+	copilot: new Set([
+		"Write",
+		"Edit",
+		"MultiEdit",
+		"NotebookEdit"
+	])
+};
+const GATE_DENY_REASON = "Blocked: load matching TanStack guidance before editing. Follow this repo's TanStack guidance setup, then retry the edit.";
+//#endregion
+//#region src/hooks/install.ts
+const STATUS_MESSAGE = "Checking Intent guidance";
+function runInstallHooks({ agents, copilotHome, homeDir = homedir(), root, scope }) {
+	const resolvedScope = parseScope(scope);
+	return parseAgents(agents).map((agent) => installAgentHook({
+		agent,
+		copilotHome,
+		homeDir,
+		root,
+		scope: resolvedScope
+	}));
+}
+function validateHookInstallOptions({ agents, scope }) {
+	parseScope(scope);
+	parseAgents(agents);
+}
+function buildHookRunnerScript(agent) {
+	const editTools = [...EDIT_TOOLS_BY_AGENT[agent]].sort();
+	return `#!/usr/bin/env node
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { createHash } from 'node:crypto'
+
+const AGENT = ${JSON.stringify(agent)}
+const EDIT_TOOLS = new Set(${JSON.stringify(editTools)})
+const GATE_DENY_REASON = ${JSON.stringify(GATE_DENY_REASON)}
+const INTENT_COMMAND_PATTERN = /(?:^|&&|\\|\\||;|\\|)\\s*((?:bunx\\s+@tanstack\\/intent(?:@latest)?)|(?:pnpm\\s+exec\\s+intent)|(?:pnpm\\s+dlx\\s+@tanstack\\/intent(?:@latest)?)|(?:npx\\s+@tanstack\\/intent(?:@latest)?)|(?:yarn\\s+dlx\\s+@tanstack\\/intent(?:@latest)?)|(?:intent))\\s+(list|load)(?:\\s+([^\\s|;&]+))?/i
+
+try {
+  const event = readEventFromStdin()
+  const stateFile = stateFileForEvent(event)
+  const observation = observationFromEvent(event)
+
+  if (observation) {
+    appendObservation(stateFile, observation)
+  }
+
+  const toolName = event?.tool_name ?? event?.toolName
+  if (typeof toolName === 'string' && EDIT_TOOLS.has(toolName) && !hasLoad(stateFile)) {
+    process.stdout.write(JSON.stringify(denyOutput()))
+  }
+} catch {
+}
+
+process.exit(0)
+
+function readEventFromStdin() {
+  try {
+    return JSON.parse(readFileSync(0, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function stateFileForEvent(event) {
+  const sessionId = typeof event?.session_id === 'string' ? event.session_id : 'unknown'
+  const cwd = typeof event?.cwd === 'string' ? event.cwd : process.cwd()
+  const key = createHash('sha256').update(AGENT + '\\0' + cwd + '\\0' + sessionId).digest('hex')
+  return join(tmpdir(), 'tanstack-intent-hooks', key + '.jsonl')
+}
+
+function observationFromEvent(event) {
+  if (!event || typeof event !== 'object') return undefined
+  const toolName = event.tool_name ?? event.toolName
+  const toolInput = event.tool_input ?? event.toolArgs
+  if (toolName !== 'Bash') return undefined
+  const command = typeof toolInput === 'string' ? safeCommandFromString(toolInput) : commandFromObject(toolInput)
+  const parsed = parseIntentInvocation(command)
+  if (!parsed || typeof command !== 'string') return undefined
+  return { action: parsed.action, skillUse: parsed.skillUse, raw: command }
+}
+
+function parseIntentInvocation(command) {
+  if (typeof command !== 'string') return undefined
+  const match = command.match(INTENT_COMMAND_PATTERN)
+  if (!match?.[1] || !match[2]) return undefined
+  const action = match[2].toLowerCase()
+  if (action !== 'list' && action !== 'load') return undefined
+  const skillUse = action === 'load' ? match[3] : undefined
+  if (action === 'load' && !skillUse) return undefined
+  return action === 'load' ? { action, skillUse } : { action }
+}
+
+function commandFromObject(value) {
+  return value && typeof value === 'object' ? value.command : undefined
+}
+
+function safeCommandFromString(value) {
+  try {
+    const command = commandFromObject(JSON.parse(value))
+    return typeof command === 'string' ? command : value
+  } catch {
+    return value
+  }
+}
+
+function appendObservation(stateFile, observation) {
+  try {
+    mkdirSync(dirname(stateFile), { recursive: true })
+    appendFileSync(stateFile, JSON.stringify({ ts: new Date().toISOString(), ...observation }) + '\\n')
+  } catch {
+  }
+}
+
+function hasLoad(stateFile) {
+  if (!existsSync(stateFile)) return false
+  try {
+    return readFileSync(stateFile, 'utf8')
+      .split('\\n')
+      .filter(Boolean)
+      .some((line) => {
+        try {
+          return JSON.parse(line).action === 'load'
+        } catch {
+          return false
+        }
+      })
+  } catch {
+    return false
+  }
+}
+
+function denyOutput() {
+  if (AGENT === 'copilot') {
+    return { permissionDecision: 'deny', permissionDecisionReason: GATE_DENY_REASON }
+  }
+
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: GATE_DENY_REASON,
+    },
+  }
+}
+`;
+}
+function formatHookInstallResult(result) {
+	if (result.status === "skipped") return `Skipped Intent hooks for ${result.agent}: ${result.reason}`;
+	const target = result.configPath ? formatPath(result.configPath) : result.agent;
+	switch (result.status) {
+		case "created": return `Installed Intent hooks for ${result.agent} (${result.scope}) in ${target}.`;
+		case "updated": return `Updated Intent hooks for ${result.agent} (${result.scope}) in ${target}.`;
+		case "unchanged": return `No changes to Intent hooks for ${result.agent} (${result.scope}); already current.`;
+	}
+}
+function installAgentHook({ agent, copilotHome, homeDir, root, scope }) {
+	const adapter = HOOK_AGENT_ADAPTERS[agent];
+	if (!adapter.supportedScopes.has(scope)) return {
+		agent,
+		configPath: null,
+		reason: "project scope is not supported; use --scope user",
+		scope,
+		scriptPath: null,
+		status: "skipped"
+	};
+	const { configPath, scriptPath } = adapter.paths(scope, {
+		copilotHome: copilotHome ?? process.env.COPILOT_HOME,
+		homeDir,
+		root
+	});
+	return hookInstallResult({
+		agent,
+		configPath,
+		scope,
+		scriptPath,
+		scriptStatus: writeIfChanged(scriptPath, buildHookRunnerScript(agent)),
+		configStatus: updateJsonConfig(configPath, (config) => upsertAdapterPreToolUseHook({
+			config,
+			configKind: adapter.configKind,
+			project: scope === "project",
+			scriptPath
+		}))
+	});
+}
+function hookInstallResult({ agent, configPath, configStatus, scope, scriptPath, scriptStatus }) {
+	return {
+		agent,
+		configPath,
+		scope,
+		scriptPath,
+		status: scriptStatus === "created" || configStatus === "created" ? "created" : scriptStatus === "updated" || configStatus === "updated" ? "updated" : "unchanged"
+	};
+}
+function upsertAdapterPreToolUseHook({ config, configKind, project, scriptPath }) {
+	switch (configKind) {
+		case "claude-settings": return upsertClaudePreToolUseHook(config, project, scriptPath);
+		case "codex-hooks": return upsertCodexPreToolUseHook(config, project, scriptPath);
+		case "copilot-hooks": return upsertCopilotPreToolUseHook(config, scriptPath);
+	}
+}
+function upsertClaudePreToolUseHook(config, project, scriptPath) {
+	const hooks = objectValue(config.hooks);
+	hooks.PreToolUse = upsertHookGroup(arrayValue(hooks.PreToolUse), {
+		matcher: "Bash|Write|Edit|MultiEdit|NotebookEdit",
+		hooks: [{
+			type: "command",
+			command: "node",
+			args: [project ? "${CLAUDE_PROJECT_DIR}/.intent/hooks/intent-claude-gate.mjs" : scriptPath],
+			timeout: 10,
+			statusMessage: STATUS_MESSAGE
+		}]
+	});
+	return {
+		...config,
+		hooks
+	};
+}
+function upsertCodexPreToolUseHook(config, project, scriptPath) {
+	const hooks = objectValue(config.hooks);
+	hooks.PreToolUse = upsertHookGroup(arrayValue(hooks.PreToolUse), {
+		matcher: "Bash|apply_patch|Edit|Write",
+		hooks: [{
+			type: "command",
+			command: project ? "node \"$(git rev-parse --show-toplevel)/.intent/hooks/intent-codex-gate.mjs\"" : `node ${quoteShell(scriptPath)}`,
+			timeout: 10,
+			statusMessage: STATUS_MESSAGE
+		}]
+	});
+	return {
+		...config,
+		hooks
+	};
+}
+function upsertCopilotPreToolUseHook(config, scriptPath) {
+	const hooks = objectValue(config.hooks);
+	hooks.PreToolUse = upsertHookGroup(arrayValue(hooks.PreToolUse), { command: `node ${quoteShell(scriptPath)}` });
+	return {
+		...config,
+		hooks
+	};
+}
+function upsertHookGroup(groups, nextGroup) {
+	return [...groups.flatMap(withoutIntentHooks), nextGroup];
+}
+function withoutIntentHooks(value) {
+	if (!value || typeof value !== "object") return [value];
+	const hooks = arrayValue(value.hooks);
+	if (hooks.length === 0) return isIntentHook(value) ? [] : [value];
+	const nextHooks = hooks.filter((hook) => !isIntentHook(hook));
+	if (nextHooks.length === hooks.length) return [value];
+	if (nextHooks.length === 0) return [];
+	return [{
+		...value,
+		hooks: nextHooks
+	}];
+}
+function isIntentHook(value) {
+	if (!value || typeof value !== "object") return false;
+	const entry = value;
+	return [typeof entry.command === "string" ? entry.command : "", ...Array.isArray(entry.args) ? entry.args.filter((arg) => typeof arg === "string") : []].some(isIntentGateScriptReference);
+}
+function isIntentGateScriptReference(value) {
+	return /(?:^|[\s"'\\/])(?:old-)?intent-(claude|codex|copilot)-gate\.mjs(?:$|[?#\s"'])/i.test(value);
+}
+function updateJsonConfig(filePath, update) {
+	const existed = existsSync(filePath);
+	const current = existed ? readFileSync(filePath, "utf8") : "";
+	const parsed = current.trim() ? parseJsonObject(filePath, current) : {};
+	const next = `${JSON.stringify(update(parsed), null, 2)}\n`;
+	if (current === next) return "unchanged";
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, next);
+	return existed ? "updated" : "created";
+}
+function writeIfChanged(filePath, content) {
+	const existed = existsSync(filePath);
+	if (existed && readFileSync(filePath, "utf8") === content) return "unchanged";
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, content);
+	return existed ? "updated" : "created";
+}
+function parseAgents(value) {
+	if (!value || value === "all") return ALL_HOOK_AGENTS;
+	const agents = value.split(",").map((agent) => agent.trim()).filter(Boolean);
+	const invalid = agents.filter((agent) => !ALL_HOOK_AGENTS.includes(agent));
+	if (invalid.length > 0) fail(`Unknown hook agent: ${invalid.join(", ")}. Expected copilot, claude, codex, or all.`);
+	return [...new Set(agents)];
+}
+function parseScope(value) {
+	if (!value) return "project";
+	if (value === "project" || value === "user") return value;
+	fail(`Unknown hook scope: ${value}. Expected project or user.`);
+}
+function parseJsonObject(filePath, content) {
+	try {
+		const parsed = JSON.parse(content);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch (err) {
+		fail(`Failed to parse ${formatPath(filePath)}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	fail(`Failed to parse ${formatPath(filePath)}: expected a JSON object.`);
+}
+function objectValue(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+function arrayValue(value) {
+	return Array.isArray(value) ? value : [];
+}
+function quoteShell(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function formatPath(filePath) {
+	return relative(process.cwd(), filePath) || filePath;
+}
+//#endregion
+//#region src/commands/hooks/command.ts
+function runHooksInstallCommand(options) {
+	validateHookInstallOptions(options);
+	const results = runInstallHooks({
+		agents: options.agents,
+		root: process.cwd(),
+		scope: options.scope
+	});
+	for (const result of results) console.log(formatHookInstallResult(result));
+}
+//#endregion
+export { runHooksInstallCommand };