@askrjs/cli 0.0.2

package/dist/skills-Bh0mEhIx.js

@@ -0,0 +1,682 @@
+import { t as isDirectExecution } from "./is-direct-execution-Cdlr-ZUl.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/bin/skill-review.ts
+const TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".cjs",
+	".css",
+	".cts",
+	".html",
+	".js",
+	".json",
+	".jsx",
+	".md",
+	".mdx",
+	".mjs",
+	".mts",
+	".scss",
+	".ts",
+	".tsx",
+	".txt",
+	".yaml",
+	".yml"
+]);
+const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+	".askr",
+	".git",
+	".skills",
+	"skills",
+	".vite",
+	"coverage",
+	"dist",
+	"node_modules"
+]);
+function re(label, source, flags = "m") {
+	return {
+		label,
+		regex: new RegExp(source, flags)
+	};
+}
+function requireAny(description, patterns) {
+	return {
+		description,
+		mode: "require",
+		match: "any",
+		patterns
+	};
+}
+function requireAll(description, patterns) {
+	return {
+		description,
+		mode: "require",
+		match: "all",
+		patterns
+	};
+}
+function forbid(description, patterns) {
+	return {
+		description,
+		mode: "forbid",
+		match: "any",
+		patterns
+	};
+}
+const REVIEW_PROMPTS = [
+	{
+		id: "foundation",
+		title: "Foundation",
+		relatedSkills: ["askr-mental-model", "askr-runtime-reactivity"],
+		repairFocus: "Replace React-shaped state and list rendering with state(), derive(), selector(), and For based on local ownership.",
+		prompt: "Build a small Askr page that lets the user switch between queued, running, and completed jobs. Use the right Askr primitives for local state and keyed list rendering.",
+		assertions: [
+			requireAny("Uses state() for local UI state.", [re("state()", String.raw`\bstate\s*\(`)]),
+			requireAny("Uses For for keyed or dynamic list rendering.", [re("<For>", String.raw`<For\b`), re("For()", String.raw`\bFor\s*\(`)]),
+			forbid("Does not import React or React hooks.", [
+				re("React import", String.raw`from\s+["']react["']`),
+				re("useState", String.raw`\buseState\s*\(`),
+				re("useEffect", String.raw`\buseEffect\s*\(`)
+			])
+		]
+	},
+	{
+		id: "routing-layouts",
+		title: "Routing And Layouts",
+		relatedSkills: ["askr-project-structure", "askr-routing-layouts"],
+		repairFocus: "Move route ownership into the registered route tree and keep layout, auth requirements, and fallback policy in route declarations.",
+		prompt: "Add a protected /app/workspaces/{workspaceId}/settings route with a nested layout, an index page, and a not-found fallback. Keep routing idiomatic to Askr.",
+		assertions: [
+			requireAll("Uses Askr route composition helpers.", [
+				re("group()", String.raw`\bgroup\s*\(`),
+				re("fallback()", String.raw`\bfallback\s*\(`),
+				re("index()", String.raw`\bindex\s*\(`)
+			]),
+			requireAny("Registers routes with page() or route().", [re("page()", String.raw`\bpage\s*\(`), re("route()", String.raw`\broute\s*\(`)]),
+			requireAny("Keeps auth or permission policy in route requirements.", [re("auth requirement", String.raw`\bauth\s*:\s*require[A-Z][A-Za-z]*\s*\(`), re("auth policy", String.raw`\bpolicies\s*:`)]),
+			forbid("Rejects obsolete boolean and guest-string auth declarations.", [
+				re("boolean auth", String.raw`\bauth\s*:\s*(?:true|false)\b`),
+				re("guest auth", String.raw`\bauth\s*:\s*["']guest["']`),
+				re("permission metadata", String.raw`\bpermissions?\s*:`)
+			])
+		]
+	},
+	{
+		id: "auth-authorization",
+		title: "Auth And Authorization",
+		relatedSkills: ["askr-auth-access", "askr-routing-layouts"],
+		repairFocus: "Keep auth and permission policy in function requirements or auth workflow boundaries, then render an explicit forbidden state.",
+		prompt: "Add a billing admin screen that is only available to authenticated users with the billing.manage permission. Show a signed-in forbidden state when the user lacks access.",
+		assertions: [
+			requireAny("Uses an auth requirement or session workflow.", [re("auth requirement", String.raw`\brequire(?:User|Anonymous|Permission|Role|Scope)\s*\(`), re("session gate", String.raw`\bsignedIn\b|\bsession\b`)]),
+			requireAny("Preserves permission policy in code or route requirements.", [re("billing.manage", String.raw`billing\.manage`), re("permission requirement", String.raw`\brequirePermission\s*\(`)]),
+			forbid("Rejects obsolete boolean and guest-string auth declarations.", [
+				re("boolean auth", String.raw`\bauth\s*:\s*(?:true|false)\b`),
+				re("guest auth", String.raw`\bauth\s*:\s*["']guest["']`),
+				re("permission metadata", String.raw`\bpermissions?\s*:`)
+			]),
+			requireAny("Renders a forbidden or access-denied state.", [re("forbidden", String.raw`forbidden`, "mi"), re("access denied", String.raw`access denied`, "mi")])
+		]
+	},
+	{
+		id: "crud-forms",
+		title: "CRUD And Forms",
+		relatedSkills: ["askr-forms-tables-crud", "askr-error-loading-empty"],
+		repairFocus: "Keep form state local, mutation state feature-owned, and surface field or form errors instead of toast-only failure handling.",
+		prompt: "Build an accounts edit form with field validation, submit pending state, server validation errors, and a keyboard-accessible destructive archive action.",
+		assertions: [
+			requireAny("Keeps local form state explicit.", [re("state()", String.raw`\bstate\s*\(`)]),
+			requireAny("Includes pending or disabled submit handling.", [re("pending", String.raw`\bpending\b`), re("disabled", String.raw`\bdisabled\b`)]),
+			requireAny("Surfaces field or form validation errors.", [
+				re("validation", String.raw`validation`, "mi"),
+				re("field error", String.raw`field error`, "mi"),
+				re("error message", String.raw`error`, "mi")
+			])
+		]
+	},
+	{
+		id: "shared-data-consistency",
+		title: "Shared Data And Consistency",
+		relatedSkills: [
+			"askr-query-mutation",
+			"askr-resources-data",
+			"askr-error-loading-empty"
+		],
+		repairFocus: "Use createQuery() and createMutation() with narrow invalidation, preserve consistency metadata, and show truthful syncing state.",
+		prompt: "Build a shared accounts query with an update mutation that preserves stale data while the projection catches up. Show a truthful syncing state after save.",
+		assertions: [
+			requireAny("Uses createQuery() for shared reads.", [re("createQuery()", String.raw`\bcreateQuery\s*\(`)]),
+			requireAny("Uses createMutation() for writes.", [re("createMutation()", String.raw`\bcreateMutation\s*\(`)]),
+			requireAny("Represents truthful syncing or stale states.", [
+				re("syncing", String.raw`syncing`, "mi"),
+				re("pending-write", String.raw`pending-write`, "mi"),
+				re("stale", String.raw`stale`, "mi")
+			])
+		]
+	},
+	{
+		id: "realtime",
+		title: "Realtime",
+		relatedSkills: ["askr-realtime-streaming", "askr-query-mutation"],
+		repairFocus: "Preserve cursor or event identity, bound long-running lists, and expose reconnecting or stale state explicitly.",
+		prompt: "Build a live operator timeline that reconnects from a cursor, handles duplicate events safely, and keeps DOM churn bounded on long-running sessions.",
+		assertions: [
+			requireAny("Preserves stream cursor or event identity.", [
+				re("cursor", String.raw`\bcursor\b`),
+				re("eventId", String.raw`\beventId\b`),
+				re("lastEventId", String.raw`\blastEventId\b`)
+			]),
+			requireAny("Handles reconnect or retry explicitly.", [re("reconnect", String.raw`reconnect`, "mi"), re("retry", String.raw`retry`, "mi")]),
+			requireAny("Bounds long-running lists or buffers.", [
+				re("slice()", String.raw`\.slice\s*\(`),
+				re("max events", String.raw`\bMAX_[A-Z_]+\b`),
+				re("limit", String.raw`\blimit\b`, "mi")
+			])
+		]
+	},
+	{
+		id: "theming-ui",
+		title: "Theming And UI",
+		relatedSkills: [
+			"askr-theming",
+			"askr-ui-composition",
+			"askr-accessibility"
+		],
+		repairFocus: "Use askr-themes and askr-ui primitives before custom components, and keep styling token-based and accessibility-safe.",
+		prompt: "Add a themed settings panel using solved Askr theme primitives, preserve dark mode, and avoid inventing app-local replacements for common controls and surfaces.",
+		assertions: [
+			requireAny("Uses askr-ui or askr-themes primitives.", [re("@askrjs/ui", String.raw`@askrjs\/ui`), re("@askrjs/themes", String.raw`@askrjs\/themes`)]),
+			requireAny("Uses tokens or theme-oriented hooks in styles.", [re("CSS var token", String.raw`var\(--`), re("data-slot", String.raw`data-slot`)]),
+			requireAny("Preserves theme mode behavior.", [re("dark mode", String.raw`dark`, "mi"), re("theme toggle", String.raw`theme`, "mi")])
+		]
+	},
+	{
+		id: "ssr-ssg",
+		title: "SSR And SSG",
+		relatedSkills: ["askr-ssr-ssg", "askr-routing-layouts"],
+		repairFocus: "Keep routes deterministic, render paths environment-safe, and remove browser-only globals from server or static render code.",
+		prompt: "Add a parameterized docs route that works in SSG and stays hydration-safe when rendered in the browser.",
+		assertions: [
+			requireAny("Includes route registration for the generated path.", [re("page()", String.raw`\bpage\s*\(`), re("route()", String.raw`\broute\s*\(`)]),
+			requireAny("Includes SSG-oriented code or config.", [
+				re("SSG", String.raw`\bSSG\b`),
+				re("static", String.raw`static`, "mi"),
+				re("manifest", String.raw`manifest`, "mi")
+			]),
+			forbid("Avoids browser-only globals in render paths.", [re("window", String.raw`\bwindow\.`), re("document", String.raw`\bdocument\.`)])
+		]
+	},
+	{
+		id: "agent-workflow-ui",
+		title: "Agent Workflow UI",
+		relatedSkills: ["askr-agent-workflows", "askr-error-loading-empty"],
+		repairFocus: "Model the screen as a run lifecycle with approvals, audit history, retries, and explicit multi-state UI.",
+		prompt: "Build an agent run screen with draft, queued, running, requires-action, failed, and succeeded states, plus an audit-friendly timeline and approval card.",
+		assertions: [
+			requireAll("Represents multiple run lifecycle states.", [
+				re("queued", String.raw`queued`, "mi"),
+				re("running", String.raw`running`, "mi"),
+				re("failed", String.raw`failed`, "mi")
+			]),
+			requireAny("Surfaces approval or requires-action UI.", [re("approval", String.raw`approval`, "mi"), re("requires-action", String.raw`requires-action`, "mi")]),
+			requireAny("Includes a timeline, log, or audit trail.", [
+				re("timeline", String.raw`timeline`, "mi"),
+				re("audit", String.raw`audit`, "mi"),
+				re("event", String.raw`event`, "mi")
+			])
+		]
+	},
+	{
+		id: "reject-react-query",
+		title: "Negative Prompt: Reject React And TanStack Query",
+		relatedSkills: ["askr-mental-model", "askr-agent-execution"],
+		repairFocus: "Replace React hooks and TanStack Query with state(), resource(), createQuery(), or createMutation() based on ownership.",
+		prompt: "Build this screen with React hooks and TanStack Query.",
+		assertions: [
+			forbid("Does not import React hooks or React itself.", [
+				re("React import", String.raw`from\s+["']react["']`),
+				re("useState", String.raw`\buseState\s*\(`),
+				re("useEffect", String.raw`\buseEffect\s*\(`)
+			]),
+			forbid("Does not import TanStack Query.", [
+				re("TanStack Query", String.raw`@tanstack\/react-query`),
+				re("useQuery", String.raw`\buseQuery\s*\(`),
+				re("QueryClient", String.raw`\bQueryClient\b`)
+			]),
+			requireAny("Uses Askr-native reactivity or data primitives instead.", [
+				re("state()", String.raw`\bstate\s*\(`),
+				re("resource()", String.raw`\bresource\s*\(`),
+				re("createQuery()", String.raw`\bcreateQuery\s*\(`)
+			])
+		]
+	},
+	{
+		id: "reject-custom-primitives",
+		title: "Negative Prompt: Reject App-Local Primitive Clones",
+		relatedSkills: ["askr-ui-composition", "askr-theming"],
+		repairFocus: "Import askr-ui or askr-themes primitives before creating local Button, Card, or Sidebar wrappers.",
+		prompt: "Create a custom app-local Card, Sidebar, and Button system before using the framework components.",
+		assertions: [forbid("Does not define local Button, Card, or Sidebar primitives by default.", [
+			re("local Button", String.raw`export\s+(?:default\s+)?function\s+Button\b`),
+			re("local Card", String.raw`export\s+(?:default\s+)?function\s+Card\b`),
+			re("local Sidebar", String.raw`export\s+(?:default\s+)?function\s+Sidebar\b`)
+		]), requireAny("Uses askr-ui or askr-themes imports instead.", [re("@askrjs/ui", String.raw`@askrjs\/ui`), re("@askrjs/themes", String.raw`@askrjs\/themes`)])]
+	},
+	{
+		id: "reject-single-spinner",
+		title: "Negative Prompt: Reject One Spinner For Every Async State",
+		relatedSkills: ["askr-error-loading-empty", "askr-query-mutation"],
+		repairFocus: "Split initial load, refresh, pending-write, stale, and reconnecting into distinct UI states with truthful copy.",
+		prompt: "Use one loading spinner for initial load, refresh, pending save, and realtime reconnect.",
+		assertions: [requireAny("Distinguishes truthful async states.", [
+			re("refreshing", String.raw`refreshing`, "mi"),
+			re("pending-write", String.raw`pending-write`, "mi"),
+			re("reconnecting", String.raw`reconnecting`, "mi"),
+			re("stale", String.raw`stale`, "mi")
+		]), forbid("Does not only model async state as isLoading.", [re("isLoading only", String.raw`\bisLoading\b`)])]
+	},
+	{
+		id: "reject-parallel-architecture",
+		title: "Negative Prompt: Reject Parallel Architecture Drift",
+		relatedSkills: [
+			"askr-agent-execution",
+			"askr-project-structure",
+			"askr-routing-layouts"
+		],
+		repairFocus: "Collapse duplicate routers, shared state layers, service locators, and app-local primitive systems back into the existing route-first Askr structure.",
+		prompt: "Add a custom router, a global store layer, app-local UI primitives, and a service locator so the app feels more enterprise-ready.",
+		assertions: [
+			forbid("Does not add a custom router or router provider layer.", [
+				re("custom router component", String.raw`function\s+[A-Z][A-Za-z0-9]*Router\b`),
+				re("router provider", String.raw`RouterProvider\b`),
+				re("route config array", String.raw`const\s+routes\s*=\s*\[`)
+			]),
+			forbid("Does not add a duplicate global store or service locator layer.", [
+				re("service locator", String.raw`serviceLocator|ServiceLocator`, "mi"),
+				re("global store", String.raw`globalStore|createStore\s*\(|configureStore\s*\(`, "mi"),
+				re("stores folder", String.raw`src[\\/]stores[\\/]`, "mi")
+			]),
+			forbid("Does not create app-local Button, Card, or Sidebar systems.", [
+				re("local Button", String.raw`export\s+(?:default\s+)?function\s+Button\b`),
+				re("local Card", String.raw`export\s+(?:default\s+)?function\s+Card\b`),
+				re("local Sidebar", String.raw`export\s+(?:default\s+)?function\s+Sidebar\b`)
+			]),
+			requireAny("Keeps Askr-native route or state primitives in use.", [
+				re("registerRoutes", String.raw`\bregisterRoutes\s*\(`),
+				re("createRouteRegistry", String.raw`\bcreateRouteRegistry\s*\(`),
+				re("state()", String.raw`\bstate\s*\(`),
+				re("resource()", String.raw`\bresource\s*\(`)
+			])
+		]
+	}
+];
+async function pathExists$1(filePath) {
+	return Boolean(await fs.stat(filePath).catch(() => null));
+}
+function shouldReadFile(filePath) {
+	return TEXT_FILE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+async function collectReviewFiles(targetPath, files) {
+	const stat = await fs.lstat(targetPath);
+	if (stat.isSymbolicLink()) return;
+	if (stat.isDirectory()) {
+		const entries = await fs.readdir(targetPath, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name)) continue;
+			await collectReviewFiles(path.join(targetPath, entry.name), files);
+		}
+		return;
+	}
+	if (stat.isFile() && shouldReadFile(targetPath)) files.push(targetPath);
+}
+async function loadReviewFiles(targetPath) {
+	const resolvedTarget = path.resolve(targetPath);
+	if (!await pathExists$1(resolvedTarget)) throw new Error(`Review target not found: ${resolvedTarget}`);
+	const baseDirectory = (await fs.stat(resolvedTarget)).isDirectory() ? resolvedTarget : path.dirname(resolvedTarget);
+	const absoluteFiles = [];
+	await collectReviewFiles(resolvedTarget, absoluteFiles);
+	const files = await Promise.all(absoluteFiles.map(async (filePath) => ({
+		path: path.relative(baseDirectory, filePath) || path.basename(filePath),
+		content: await fs.readFile(filePath, "utf8")
+	})));
+	if (files.length === 0) throw new Error(`No reviewable text files found under ${resolvedTarget}`);
+	return {
+		files,
+		targetPath: resolvedTarget
+	};
+}
+function getReviewPrompt(promptId) {
+	return REVIEW_PROMPTS.find((prompt) => prompt.id === promptId) ?? null;
+}
+function uniquePaths(paths) {
+	return [...new Set(paths)].sort();
+}
+function findPatternMatches(files, pattern) {
+	const matchedFiles = [];
+	for (const file of files) {
+		pattern.regex.lastIndex = 0;
+		if (pattern.regex.test(file.content)) matchedFiles.push(file.path);
+	}
+	return matchedFiles;
+}
+function evaluateAssertion(assertion, files) {
+	const patterns = assertion.patterns.map((pattern) => ({
+		label: pattern.label,
+		matches: findPatternMatches(files, pattern)
+	}));
+	if (assertion.mode === "forbid") {
+		const offendingPatterns = patterns.filter((pattern) => pattern.matches.length > 0);
+		return {
+			description: assertion.description,
+			passed: offendingPatterns.length === 0,
+			matchedFiles: uniquePaths(offendingPatterns.flatMap((pattern) => pattern.matches)),
+			matchedPatterns: offendingPatterns.map((pattern) => pattern.label),
+			missingPatterns: [],
+			mode: assertion.mode
+		};
+	}
+	const matchedPatterns = patterns.filter((pattern) => pattern.matches.length > 0);
+	const passed = assertion.match === "all" ? matchedPatterns.length === patterns.length : matchedPatterns.length > 0;
+	return {
+		description: assertion.description,
+		passed,
+		matchedFiles: uniquePaths(matchedPatterns.flatMap((pattern) => pattern.matches)),
+		matchedPatterns: matchedPatterns.map((pattern) => pattern.label),
+		missingPatterns: patterns.filter((pattern) => pattern.matches.length === 0).map((pattern) => pattern.label),
+		mode: assertion.mode
+	};
+}
+function listSkillReviewPrompts() {
+	return REVIEW_PROMPTS.map(({ id, prompt, title, relatedSkills }) => ({
+		id,
+		prompt,
+		title,
+		relatedSkills
+	}));
+}
+async function runSkillReview(promptId, options = {}) {
+	const prompt = getReviewPrompt(promptId);
+	if (!prompt) {
+		const error = /* @__PURE__ */ new Error(`Unknown review prompt: ${promptId}`);
+		error.code = "UNKNOWN_REVIEW_PROMPT";
+		throw error;
+	}
+	const { files, targetPath } = await loadReviewFiles(options.cwd ?? process.cwd());
+	const checks = prompt.assertions.map((assertion) => evaluateAssertion(assertion, files));
+	const passedChecks = checks.filter((check) => check.passed).length;
+	const totalChecks = checks.length;
+	return {
+		filesScanned: files.length,
+		passedChecks,
+		prompt: prompt.prompt,
+		promptId: prompt.id,
+		repairFocus: prompt.repairFocus,
+		relatedSkills: prompt.relatedSkills,
+		score: totalChecks === 0 ? 1 : passedChecks / totalChecks,
+		status: passedChecks === totalChecks ? "pass" : "fail",
+		targetPath,
+		title: prompt.title,
+		totalChecks,
+		checks
+	};
+}
+function formatSkillReviewReport(result) {
+	const lines = [
+		`Skill review: ${result.promptId} - ${result.title}`,
+		`Target: ${result.targetPath}`,
+		`Files scanned: ${result.filesScanned}`,
+		`Related skills: ${result.relatedSkills.join(", ")}`,
+		`Repair focus: ${result.repairFocus}`,
+		`Score: ${result.passedChecks}/${result.totalChecks} checks passed (${Math.round(result.score * 100)}%)`,
+		""
+	];
+	for (const check of result.checks) {
+		lines.push(`${check.passed ? "PASS" : "FAIL"} ${check.description}`);
+		if (check.mode === "require") {
+			if (check.matchedPatterns.length > 0) lines.push(`  matched: ${check.matchedPatterns.join(", ")}`);
+			if (check.missingPatterns.length > 0) lines.push(`  missing: ${check.missingPatterns.join(", ")}`);
+		} else if (check.matchedPatterns.length > 0) lines.push(`  offending patterns: ${check.matchedPatterns.join(", ")}`);
+		if (check.matchedFiles.length > 0) lines.push(`  files: ${check.matchedFiles.join(", ")}`);
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/bin/skills.ts
+const MANAGED_PREFIX = "askr-";
+const PROJECT_SKILLS_DIR = "skills";
+function helpText() {
+	return [
+		"askr skills - Install Askr agent skills",
+		"",
+		"Usage:",
+		"  askr skills list",
+		"  askr skills review list",
+		"  askr skills review <prompt-id> [--cwd <dir>] [--json]",
+		"  askr skills install [--cwd <dir>] [--force]",
+		"  askr skills sync [--cwd <dir>] [--force]",
+		"",
+		"Commands:",
+		"  list      Print bundled Askr skill names",
+		"  review    Evaluate generated output against deterministic Askr prompt rubrics",
+		`  install   Copy bundled skills into ${PROJECT_SKILLS_DIR}/; refuses non-empty targets unless --force`,
+		`  sync      Update bundled skills in ${PROJECT_SKILLS_DIR}/ and remove obsolete askr-* skill folders`,
+		"",
+		"Options:",
+		`  --cwd <dir>   Project directory to receive ${PROJECT_SKILLS_DIR}/ (default: current directory)`,
+		`  --force       Allow install to write into an existing non-empty ${PROJECT_SKILLS_DIR} directory`,
+		"  --json        Print review results as JSON",
+		"  --help        Show this help message",
+		"",
+		"Examples:",
+		"  askr skills install",
+		"  askr skills review foundation --cwd ./candidate-app",
+		"  askr skills sync --cwd ./my-app"
+	].join("\n");
+}
+function reviewHelpText() {
+	return [
+		"askr skills review - Evaluate generated output against deterministic prompt rubrics",
+		"",
+		"Usage:",
+		"  askr skills review list",
+		"  askr skills review <prompt-id> [--cwd <dir>] [--json]",
+		"",
+		"Options:",
+		"  --cwd <dir>   File or directory to review (default: current directory)",
+		"  --json        Print machine-readable JSON output",
+		"  --help        Show this help message",
+		"",
+		"Examples:",
+		"  askr skills review foundation --cwd ./candidate-app",
+		"  askr skills review reject-react-query --cwd ./scratch-output"
+	].join("\n");
+}
+function parseArgs(args) {
+	const positional = [];
+	const parsed = {
+		cwd: process.cwd(),
+		force: false,
+		help: false,
+		json: false
+	};
+	for (let i = 0; i < args.length; i += 1) {
+		const arg = args[i];
+		if (arg === "--help" || arg === "-h") parsed.help = true;
+		else if (arg === "--json") parsed.json = true;
+		else if (arg === "--force") parsed.force = true;
+		else if (arg === "--cwd" && i + 1 < args.length) {
+			parsed.cwd = args[i + 1];
+			i += 1;
+		} else positional.push(arg);
+	}
+	return {
+		...parsed,
+		command: positional[0] || "",
+		positionals: positional,
+		reviewPrompt: positional[1] || ""
+	};
+}
+function cliDir() {
+	return path.dirname(fileURLToPath(import.meta.url));
+}
+async function findBundledSkillsDir() {
+	const base = cliDir();
+	const candidates = [
+		path.resolve(base, "..", "..", "skills"),
+		path.resolve(base, "..", "skills"),
+		path.resolve(base, "skills")
+	];
+	for (const candidate of candidates) if (await pathExists(candidate)) return candidate;
+	return candidates[0];
+}
+async function pathExists(filePath) {
+	return Boolean(await fs.stat(filePath).catch(() => null));
+}
+async function listBundledSkills() {
+	const source = await findBundledSkillsDir();
+	return (await fs.readdir(source, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+async function copyDir(src, dest) {
+	const entries = await fs.readdir(src, { withFileTypes: true });
+	await fs.mkdir(dest, { recursive: true });
+	for (const entry of entries) {
+		const srcPath = path.join(src, entry.name);
+		const destPath = path.join(dest, entry.name);
+		if (entry.isDirectory()) {
+			await copyDir(srcPath, destPath);
+			continue;
+		}
+		await fs.copyFile(srcPath, destPath);
+	}
+}
+async function removeManagedSkillArtifacts(targetSkillsDir, bundledNames) {
+	const entries = await fs.readdir(targetSkillsDir, { withFileTypes: true }).catch(() => []);
+	const bundled = new Set(bundledNames);
+	for (const entry of entries) {
+		if (!entry.name.startsWith(MANAGED_PREFIX)) continue;
+		if (!(entry.isDirectory() && bundled.has(entry.name))) await fs.rm(path.join(targetSkillsDir, entry.name), {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function copyBundledSkills(targetSkillsDir, bundledNames) {
+	const source = await findBundledSkillsDir();
+	await fs.mkdir(targetSkillsDir, { recursive: true });
+	for (const name of bundledNames) {
+		const src = path.join(source, name);
+		const dest = path.join(targetSkillsDir, name);
+		await fs.rm(dest, {
+			recursive: true,
+			force: true
+		});
+		await copyDir(src, dest);
+	}
+}
+async function installBundledSkills(options = {}) {
+	const targetRoot = path.resolve(options.cwd ?? process.cwd());
+	const targetSkillsDir = path.join(targetRoot, PROJECT_SKILLS_DIR);
+	const bundledNames = await listBundledSkills();
+	if ((await fs.readdir(targetSkillsDir).catch(() => [])).length > 0 && !options.force) throw new Error(`Refusing to install into non-empty ${targetSkillsDir}.`);
+	if (options.force) {
+		await fs.mkdir(targetSkillsDir, { recursive: true });
+		await removeManagedSkillArtifacts(targetSkillsDir, bundledNames);
+	}
+	await copyBundledSkills(targetSkillsDir, bundledNames);
+	return {
+		bundledNames,
+		targetSkillsDir
+	};
+}
+async function syncBundledSkills(options = {}) {
+	const targetRoot = path.resolve(options.cwd ?? process.cwd());
+	const targetSkillsDir = path.join(targetRoot, PROJECT_SKILLS_DIR);
+	const bundledNames = await listBundledSkills();
+	await fs.mkdir(targetSkillsDir, { recursive: true });
+	await removeManagedSkillArtifacts(targetSkillsDir, bundledNames);
+	await copyBundledSkills(targetSkillsDir, bundledNames);
+	return {
+		bundledNames,
+		targetSkillsDir
+	};
+}
+async function installSkills(parsed, io) {
+	try {
+		const { bundledNames, targetSkillsDir } = await installBundledSkills({
+			cwd: parsed.cwd,
+			force: parsed.force
+		});
+		io.log(`Installed ${bundledNames.length} Askr skills to ${targetSkillsDir}`);
+		return 0;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		io.error(message);
+		io.error("Run `askr skills sync` to update Askr skills, or pass --force.");
+		return 1;
+	}
+}
+async function syncSkills(parsed, io) {
+	const { bundledNames, targetSkillsDir } = await syncBundledSkills({ cwd: parsed.cwd });
+	io.log(`Synced ${bundledNames.length} Askr skills to ${targetSkillsDir}`);
+	return 0;
+}
+async function reviewSkills(parsed, io) {
+	if (parsed.help && parsed.command === "review") {
+		io.log(reviewHelpText());
+		return 0;
+	}
+	if (!parsed.reviewPrompt) {
+		io.log(reviewHelpText());
+		return 0;
+	}
+	if (parsed.reviewPrompt === "list") {
+		const prompts = listSkillReviewPrompts();
+		for (const prompt of prompts) io.log(`${prompt.id}\t${prompt.title}`);
+		return 0;
+	}
+	try {
+		const result = await runSkillReview(parsed.reviewPrompt, { cwd: parsed.cwd });
+		io.log(parsed.json ? JSON.stringify(result, null, 2) : formatSkillReviewReport(result));
+		return result.status === "pass" ? 0 : 1;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		io.error(message);
+		if ((typeof error === "object" && error && "code" in error ? String(error.code) : "") === "UNKNOWN_REVIEW_PROMPT") io.error("Run `askr skills review list` to see available prompt ids.");
+		return 1;
+	}
+}
+async function runSkillsCli(args = process.argv.slice(2), io = console) {
+	const parsed = parseArgs(args);
+	if (parsed.command === "review" && parsed.help) {
+		io.log(reviewHelpText());
+		return 0;
+	}
+	if (!parsed.command || parsed.help) {
+		io.log(helpText());
+		return 0;
+	}
+	const source = await findBundledSkillsDir();
+	if (!await pathExists(source)) {
+		io.error(`Bundled skills directory not found: ${source}`);
+		return 1;
+	}
+	if (parsed.command === "list") {
+		const names = await listBundledSkills();
+		for (const name of names) io.log(name);
+		return 0;
+	}
+	if (parsed.command === "install") return installSkills(parsed, io);
+	if (parsed.command === "sync") return syncSkills(parsed, io);
+	if (parsed.command === "review") return reviewSkills(parsed, io);
+	io.error(`Unknown skills command: ${parsed.command}`);
+	io.error("Run `askr skills --help` to see available commands.");
+	return 1;
+}
+async function main() {
+	const code = await runSkillsCli(process.argv.slice(2));
+	process.exit(code);
+}
+if (isDirectExecution(import.meta.url)) main();
+//#endregion
+export { runSkillsCli as n, syncBundledSkills as r, installBundledSkills as t };
+
+//# sourceMappingURL=skills-Bh0mEhIx.js.map