@askrjs/cli 0.0.3 → 0.0.4

package/dist/generate.js

@@ -1,5 +1,5 @@
-import { mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
+import { mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { load } from "js-yaml";
 //#region src/generate/generator.ts
@@ -34,6 +34,17 @@ function schemaType(schema, at, direction = "response") {
 		const name = decodeURIComponent(String(schema.$ref).split("/").at(-1));
 		return pascal(name);
 	}
+	if (Array.isArray(schema.type)) {
+		const includesNull = schema.type.includes("null");
+		const rendered = [...new Set(schema.type.filter((value) => value !== "null"))].map((variant) => schemaType({
+			...schema,
+			type: variant,
+			nullable: false
+		}, at, direction));
+		if (includesNull) rendered.push("null");
+		if (rendered.length === 0) fail("Schema type array must not be empty", at);
+		return [...new Set(rendered)].join(" | ");
+	}
 	if (schema.const !== void 0) return JSON.stringify(schema.const);
 	if (schema.enum) return schema.enum.map((value) => JSON.stringify(value)).join(" | ") || "never";
 	if (schema.oneOf || schema.anyOf) return (schema.oneOf ?? schema.anyOf).map((item, i) => schemaType(item, `${at}/${schema.oneOf ? "oneOf" : "anyOf"}/${i}`, direction)).join(" | ");
@@ -230,18 +241,31 @@ function generateFiles(document) {
 		if (seen.has(id)) fail("Duplicate operationId", `${at}/operationId`, id);
 		seen.add(id);
 		if (operation.callbacks) fail("Callbacks are unsupported", `${at}/callbacks`, id);
-		const parameters = [...document.paths[path].parameters ?? [], ...operation.parameters ?? []];
+		const parametersByIdentity = /* @__PURE__ */ new Map();
+		for (const parameter of [...document.paths[path].parameters ?? [], ...operation.parameters ?? []]) {
+			if (parameter.$ref) fail("Parameter references must be bundled", `${at}/parameters`, id);
+			if (typeof parameter.name !== "string" || typeof parameter.in !== "string") fail("Parameters require string name and in fields", `${at}/parameters`, id);
+			parametersByIdentity.set(`${parameter.in}\0${parameter.name}`, parameter);
+		}
+		const parameters = [...parametersByIdentity.values()];
 		const byLocation = {
 			path: [],
 			query: [],
 			header: []
 		};
 		for (const parameter of parameters) {
-			if (parameter.$ref) fail("Parameter references must be bundled", `${at}/parameters`, id);
 			if (parameter.in === "cookie") fail("Cookie parameters are unsupported", `${at}/parameters`, id);
 			if (!byLocation[parameter.in]) fail(`Unsupported parameter location ${parameter.in}`, `${at}/parameters`, id);
 			byLocation[parameter.in].push(parameter);
 		}
+		const templateParameters = new Set([...path.matchAll(/\{([^{}]+)\}/g)].map((match) => match[1]));
+		const declaredPathParameters = new Set(byLocation.path.map((parameter) => parameter.name));
+		for (const name of templateParameters) {
+			const parameter = byLocation.path.find((candidate) => candidate.name === name);
+			if (!parameter) fail(`Path template parameter ${name} is not declared`, `${at}/parameters`, id);
+			if (!parameter || parameter.required !== true) fail(`Path parameter ${name} must be required`, `${at}/parameters`, id);
+		}
+		for (const name of declaredPathParameters) if (!templateParameters.has(name)) fail(`Path parameter ${name} is not present in the path template`, `${at}/parameters`, id);
 		const prefix = pascal(id);
 		const renderParameters = (location) => {
 			const list = byLocation[location].sort((a, b) => a.name.localeCompare(b.name));
@@ -319,6 +343,8 @@ async function existingFiles(directory) {
 }
 async function writeGenerated(directory, files, check) {
 	const output = resolve(directory);
+	const outputStat = await stat(output).catch(() => null);
+	if (outputStat && !outputStat.isDirectory()) throw new GenerationError(`Generated output must be a directory: ${output}`);
 	const entries = await existingFiles(output);
 	if (check) {
 		if (!entries.length) throw new GenerationError(`Generated directory is missing: ${output}`);
@@ -357,6 +383,11 @@ async function writeGenerated(directory, files, check) {
 	}
 }
 async function generate(input, output, check = false) {
+	if (!/^https?:\/\//.test(input)) {
+		const resolvedInput = resolve(input);
+		const inputWithinOutput = relative(resolve(output), resolvedInput);
+		if (!inputWithinOutput.startsWith("..") && !isAbsolute(inputWithinOutput)) throw new GenerationError("Generated output must not contain its OpenAPI input document");
+	}
 	const files = generateFiles(await loadOpenApi(input));
 	await mkdir(dirname(resolve(output)), { recursive: true });
 	await writeGenerated(output, files, check);
@@ -364,33 +395,67 @@ async function generate(input, output, check = false) {
 //#endregion
 //#region src/bin/generate.ts
 async function runGenerateCli(args, io = console) {
+	const wantsJson = args.includes("--json");
 	let output;
 	let check = false;
+	let json = false;
+	let help = false;
 	const inputs = [];
 	for (let i = 0; i < args.length; i++) {
 		const arg = args[i];
 		if (arg === "--check") check = true;
-		else if (arg === "-o" || arg === "--output") output = args[++i];
-		else if (arg.startsWith("--output=")) output = arg.slice(9);
+		else if (arg === "--json") json = true;
+		else if (arg === "--help" || arg === "-h") help = true;
+		else if (arg === "-o" || arg === "--output") {
+			const value = args[i + 1];
+			if (!value || value.startsWith("-")) {
+				const message = `${arg} requires a path`;
+				io.error(wantsJson ? JSON.stringify({
+					status: "error",
+					error: message
+				}) : message);
+				return 1;
+			}
+			output = value;
+			i += 1;
+		} else if (arg.startsWith("--output=")) output = arg.slice(9);
 		else if (arg.startsWith("-")) {
-			io.error(`Unknown option: ${arg}`);
+			const message = `Unknown option: ${arg}`;
+			io.error(wantsJson ? JSON.stringify({
+				status: "error",
+				error: message
+			}) : message);
 			return 1;
 		} else inputs.push(arg);
 	}
+	const usage = "Usage: askr generate <input> -o <output-directory> [--check] [--json]";
+	if (help) {
+		io.log(usage);
+		return 0;
+	}
 	if (inputs.length !== 1 || !output) {
-		io.error("Usage: askr generate <input> -o <output-directory> [--check]");
+		io.error(json ? JSON.stringify({
+			status: "error",
+			error: usage
+		}) : usage);
 		return 1;
 	}
 	try {
 		await generate(inputs[0], output, check);
-		io.log(check ? "Generated client is current." : `Generated client in ${output}.`);
+		io.log(json ? JSON.stringify({
+			status: "ok",
+			action: check ? "checked" : "generated",
+			output
+		}) : check ? "Generated client is current." : `Generated client in ${output}.`);
 		return 0;
 	} catch (error) {
-		io.error(error instanceof Error ? error.message : String(error));
+		const message = error instanceof Error ? error.message : String(error);
+		io.error(json ? JSON.stringify({
+			status: "error",
+			error: message
+		}) : message);
 		return 1;
 	}
 }
 //#endregion
 export { runGenerateCli };
-
-//# sourceMappingURL=generate.js.map

package/dist/is-direct-execution-Cdlr-ZUl.js

@@ -16,5 +16,3 @@ function isDirectExecution(moduleUrl, argvPath = process.argv[1]) {
 }
 //#endregion
 export { isDirectExecution as t };
-
-//# sourceMappingURL=is-direct-execution-Cdlr-ZUl.js.map

package/dist/openapi.d.ts

@@ -0,0 +1,25 @@
+//#region src/bin/openapi.d.ts
+type CliIo = Pick<Console, "error" | "log">;
+interface ParsedArgs {
+  entry: string;
+  output: string;
+  check: boolean;
+  help: boolean;
+  json: boolean;
+}
+interface OpenApiDeps {
+  cwd(): string;
+  importModule(filePath: string): Promise<unknown>;
+  readFile(filePath: string): Promise<string>;
+  mkdir(directory: string): Promise<void>;
+  writeFile(filePath: string, contents: string): Promise<void>;
+  rename(from: string, to: string): Promise<void>;
+  rm(filePath: string): Promise<void>;
+  temporarySuffix(): string;
+}
+declare function parseOpenApiArgs(args: readonly string[]): ParsedArgs;
+declare function serializeOpenApi(document: unknown): string;
+declare function validateOpenApiDocument(document: unknown): asserts document is Record<string, unknown>;
+declare function runOpenApiCli(args?: string[], io?: CliIo, overrides?: Partial<OpenApiDeps>): Promise<number>;
+//#endregion
+export { parseOpenApiArgs, runOpenApiCli, serializeOpenApi, validateOpenApiDocument };

package/dist/openapi.js

@@ -15,6 +15,7 @@ Options:
   --entry <path>   TypeScript API module (default: ./src/api.ts)
   --output <path>  YAML artifact (default: ./openapi.yml)
   --check          Fail when the artifact is missing or byte-stale; never write
+  --json           Print machine-readable command results
   --help, -h       Show help
 `;
 const defaultDeps = {
@@ -32,17 +33,19 @@ function parseOpenApiArgs(args) {
 		entry: "./src/api.ts",
 		output: "./openapi.yml",
 		check: false,
-		help: false
+		help: false,
+		json: false
 	};
 	for (let index = 0; index < args.length; index += 1) {
 		const value = args[index];
 		if (value === "--entry" || value === "--output") {
 			const next = args[index + 1];
-			if (!next) throw new Error(`${value} requires a path`);
+			if (!next || next.startsWith("-")) throw new Error(`${value} requires a path`);
 			if (value === "--entry") parsed.entry = next;
 			else parsed.output = next;
 			index += 1;
 		} else if (value === "--check") parsed.check = true;
+		else if (value === "--json") parsed.json = true;
 		else if (value === "--help" || value === "-h") parsed.help = true;
 		else throw new Error(`Unknown option: ${value}`);
 	}
@@ -62,9 +65,18 @@ function serializeOpenApi(document) {
 		noRefs: true
 	}).replace(/\n+$/, "")}\n`;
 }
-async function generate(entry, deps) {
-	const document = exporterFrom(await deps.importModule(entry)).toOpenApiDocument();
+function validateOpenApiDocument(document) {
 	if (!document || typeof document !== "object" || Array.isArray(document)) throw new Error("toOpenApiDocument() must return an OpenAPI document object");
+	const candidate = document;
+	if (typeof candidate.openapi !== "string" || !/^3\.(?:0|1)\.\d+(?:[-+].+)?$/.test(candidate.openapi)) throw new Error("OpenAPI document must declare a supported openapi 3.0.x or 3.1.x version");
+	if (!candidate.info || typeof candidate.info !== "object" || Array.isArray(candidate.info)) throw new Error("OpenAPI document must contain an info object");
+	const info = candidate.info;
+	if (typeof info.title !== "string" || !info.title.trim() || typeof info.version !== "string" || !info.version.trim()) throw new Error("OpenAPI info must contain non-empty title and version strings");
+	if (!candidate.paths || typeof candidate.paths !== "object" || Array.isArray(candidate.paths)) throw new Error("OpenAPI document must contain a paths object");
+}
+async function generate(entry, deps) {
+	const document = await exporterFrom(await deps.importModule(entry)).toOpenApiDocument();
+	validateOpenApiDocument(document);
 	return serializeOpenApi(document);
 }
 async function atomicWrite(output, contents, deps) {
@@ -83,6 +95,7 @@ async function runOpenApiCli(args = process.argv.slice(2), io = console, overrid
 		...defaultDeps,
 		...overrides
 	};
+	const wantsJson = args.includes("--json");
 	try {
 		const parsed = parseOpenApiArgs(args);
 		if (parsed.help) {
@@ -91,6 +104,7 @@ async function runOpenApiCli(args = process.argv.slice(2), io = console, overrid
 		}
 		const entry = path.resolve(deps.cwd(), parsed.entry);
 		const output = path.resolve(deps.cwd(), parsed.output);
+		if (entry === output) throw new Error("OpenAPI output must not overwrite its source entry");
 		const expected = await generate(entry, deps);
 		if (parsed.check) {
 			let actual;
@@ -98,23 +112,43 @@ async function runOpenApiCli(args = process.argv.slice(2), io = console, overrid
 				actual = await deps.readFile(output);
 			} catch (error) {
 				if (error.code === "ENOENT") {
-					io.error(`OpenAPI artifact is missing: ${output}`);
+					io.error(parsed.json ? JSON.stringify({
+						status: "error",
+						reason: "missing",
+						output
+					}) : `OpenAPI artifact is missing: ${output}`);
 					return 1;
 				}
 				throw error;
 			}
 			if (actual !== expected) {
-				io.error(`OpenAPI artifact is stale: ${output}`);
+				io.error(parsed.json ? JSON.stringify({
+					status: "error",
+					reason: "stale",
+					output
+				}) : `OpenAPI artifact is stale: ${output}`);
 				return 1;
 			}
-			io.log(`OpenAPI artifact is current: ${output}`);
+			io.log(parsed.json ? JSON.stringify({
+				status: "ok",
+				action: "checked",
+				output
+			}) : `OpenAPI artifact is current: ${output}`);
 			return 0;
 		}
 		await atomicWrite(output, expected, deps);
-		io.log(`Generated OpenAPI artifact: ${output}`);
+		io.log(parsed.json ? JSON.stringify({
+			status: "ok",
+			action: "generated",
+			output
+		}) : `Generated OpenAPI artifact: ${output}`);
 		return 0;
 	} catch (error) {
-		io.error(error instanceof Error ? error.message : String(error));
+		const message = error instanceof Error ? error.message : String(error);
+		io.error(wantsJson ? JSON.stringify({
+			status: "error",
+			error: message
+		}) : message);
 		return 1;
 	}
 }
@@ -123,6 +157,4 @@ async function main() {
 }
 if (isDirectExecution(import.meta.url)) main();
 //#endregion
-export { parseOpenApiArgs, runOpenApiCli, serializeOpenApi };
-
-//# sourceMappingURL=openapi.js.map
+export { parseOpenApiArgs, runOpenApiCli, serializeOpenApi, validateOpenApiDocument };

package/dist/planner-VAj7qlxr.js

@@ -283,5 +283,3 @@ function planUpdates(options) {
 }
 //#endregion
 export { planUpdates };
-
-//# sourceMappingURL=planner-VAj7qlxr.js.map

package/dist/range-YUs9eimn.js

@@ -123,5 +123,3 @@ function rewriteRange(shape, target, forcedBreaking) {
 }
 //#endregion
 export { isBreakingChange as n, rewriteRange as r, analyzeRange as t };
-
-//# sourceMappingURL=range-YUs9eimn.js.map

package/dist/registry-CyrRHRG5.js

@@ -207,5 +207,3 @@ async function fetchPackuments(packageNames, configuration, options = {}) {
 }
 //#endregion
 export { fetchPackuments, loadNpmConfiguration };
-
-//# sourceMappingURL=registry-CyrRHRG5.js.map

package/dist/skills/askr-ssr-ssg/SKILL.md

@@ -28,7 +28,8 @@ Use this when the app renders outside the browser or produces static output. The
 2. Register routes at module load before boot or render.
 3. Keep render paths deterministic and environment-safe.
 4. Use route `entries` or the template's static config for parameterized SSG paths.
-5. Build and preview after changes that cross the render boundary.
+5. Set the canonical `siteUrl` and explicitly exclude non-indexable routes in `sitemap.routes`.
+6. Build and preview after changes that cross the render boundary.
 
 ## Copy This Shape
 
@@ -61,6 +62,7 @@ npx @askrjs/cli ssg --config ./ssg.config.ts --output ./dist/static
 - SSR or SSG build output is deterministic for the same inputs.
 - Hydration has no structural mismatch warnings.
 - Generated static routes cover expected params.
+- `sitemap.xml` contains every intended canonical route and excludes runtime-only or non-indexable routes.
 - Browser preview still navigates correctly after hydration.
 
 ## Done When

package/dist/{skills-Bh0mEhIx.js → skills-B7CbWur9.js}

@@ -1,6 +1,8 @@
 import { t as isDirectExecution } from "./is-direct-execution-Cdlr-ZUl.js";
+import { n as publishStagedDirectory, t as createSiblingStage } from "./directory-swap-DWoHtx7C.js";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { constants } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/bin/skill-review.ts
 const TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -312,29 +314,41 @@ const REVIEW_PROMPTS = [
 async function pathExists$1(filePath) {
 	return Boolean(await fs.stat(filePath).catch(() => null));
 }
+const MAX_REVIEW_FILES = 1e4;
+const MAX_REVIEW_FILE_BYTES = 2 * 1024 * 1024;
+const MAX_REVIEW_TOTAL_BYTES = 20 * 1024 * 1024;
 function shouldReadFile(filePath) {
 	return TEXT_FILE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
 }
-async function collectReviewFiles(targetPath, files) {
+async function collectReviewFiles(targetPath, state) {
 	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);
+			await collectReviewFiles(path.join(targetPath, entry.name), state);
 		}
 		return;
 	}
-	if (stat.isFile() && shouldReadFile(targetPath)) files.push(targetPath);
+	if (stat.isFile() && shouldReadFile(targetPath)) {
+		if (stat.size > MAX_REVIEW_FILE_BYTES) throw new Error(`Review file exceeds ${MAX_REVIEW_FILE_BYTES} bytes: ${targetPath}`);
+		if (state.files.length >= MAX_REVIEW_FILES) throw new Error(`Review target exceeds ${MAX_REVIEW_FILES} text files`);
+		state.totalBytes += stat.size;
+		if (state.totalBytes > MAX_REVIEW_TOTAL_BYTES) throw new Error(`Review target exceeds ${MAX_REVIEW_TOTAL_BYTES} text bytes`);
+		state.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) => ({
+	const collection = {
+		files: [],
+		totalBytes: 0
+	};
+	await collectReviewFiles(resolvedTarget, collection);
+	const files = await Promise.all(collection.files.map(async (filePath) => ({
 		path: path.relative(baseDirectory, filePath) || path.basename(filePath),
 		content: await fs.readFile(filePath, "utf8")
 	})));
@@ -496,17 +510,23 @@ function parseArgs(args) {
 		cwd: process.cwd(),
 		force: false,
 		help: false,
-		json: false
+		json: false,
+		errors: []
 	};
 	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);
+		else if (arg === "--cwd") {
+			const value = args[i + 1];
+			if (!value || value.startsWith("-")) parsed.errors.push("Missing value for --cwd");
+			else {
+				parsed.cwd = value;
+				i += 1;
+			}
+		} else if (arg.startsWith("-")) parsed.errors.push(`Unknown option: ${arg}`);
+		else positional.push(arg);
 	}
 	return {
 		...parsed,
@@ -572,16 +592,36 @@ async function copyBundledSkills(targetSkillsDir, bundledNames) {
 		await copyDir(src, dest);
 	}
 }
+async function stageSkillsDirectory(targetSkillsDir) {
+	const stage = await createSiblingStage(targetSkillsDir, "askr-skills");
+	if (await pathExists(targetSkillsDir)) await fs.cp(targetSkillsDir, stage, {
+		recursive: true,
+		mode: constants.COPYFILE_FICLONE
+	});
+	return stage;
+}
+async function replaceBundledSkills(targetSkillsDir, bundledNames) {
+	const stage = await stageSkillsDirectory(targetSkillsDir);
+	try {
+		await removeManagedSkillArtifacts(stage, bundledNames);
+		await copyBundledSkills(stage, bundledNames);
+		await publishStagedDirectory(stage, targetSkillsDir);
+	} catch (error) {
+		await fs.rm(stage, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
 async function installBundledSkills(options = {}) {
 	const targetRoot = path.resolve(options.cwd ?? process.cwd());
 	const targetSkillsDir = path.join(targetRoot, PROJECT_SKILLS_DIR);
 	const bundledNames = await listBundledSkills();
+	const targetStat = await fs.stat(targetSkillsDir).catch(() => null);
+	if (targetStat && !targetStat.isDirectory()) throw new Error(`Skills target exists and is not a directory: ${targetSkillsDir}`);
 	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);
+	await replaceBundledSkills(targetSkillsDir, bundledNames);
 	return {
 		bundledNames,
 		targetSkillsDir
@@ -591,9 +631,9 @@ 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);
+	const targetStat = await fs.stat(targetSkillsDir).catch(() => null);
+	if (targetStat && !targetStat.isDirectory()) throw new Error(`Skills target exists and is not a directory: ${targetSkillsDir}`);
+	await replaceBundledSkills(targetSkillsDir, bundledNames);
 	return {
 		bundledNames,
 		targetSkillsDir
@@ -615,9 +655,14 @@ async function installSkills(parsed, io) {
 	}
 }
 async function syncSkills(parsed, io) {
-	const { bundledNames, targetSkillsDir } = await syncBundledSkills({ cwd: parsed.cwd });
-	io.log(`Synced ${bundledNames.length} Askr skills to ${targetSkillsDir}`);
-	return 0;
+	try {
+		const { bundledNames, targetSkillsDir } = await syncBundledSkills({ cwd: parsed.cwd });
+		io.log(`Synced ${bundledNames.length} Askr skills to ${targetSkillsDir}`);
+		return 0;
+	} catch (error) {
+		io.error(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
 }
 async function reviewSkills(parsed, io) {
 	if (parsed.help && parsed.command === "review") {
@@ -646,6 +691,10 @@ async function reviewSkills(parsed, io) {
 }
 async function runSkillsCli(args = process.argv.slice(2), io = console) {
 	const parsed = parseArgs(args);
+	if (parsed.errors.length > 0) {
+		for (const error of parsed.errors) io.error(error);
+		return 1;
+	}
 	if (parsed.command === "review" && parsed.help) {
 		io.log(reviewHelpText());
 		return 0;
@@ -660,12 +709,28 @@ async function runSkillsCli(args = process.argv.slice(2), io = console) {
 		return 1;
 	}
 	if (parsed.command === "list") {
+		if (parsed.positionals.length !== 1) {
+			io.error("Usage: askr skills list");
+			return 1;
+		}
 		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 === "install") {
+		if (parsed.positionals.length !== 1) {
+			io.error("Usage: askr skills install [--cwd <dir>] [--force]");
+			return 1;
+		}
+		return installSkills(parsed, io);
+	}
+	if (parsed.command === "sync") {
+		if (parsed.positionals.length !== 1) {
+			io.error("Usage: askr skills sync [--cwd <dir>]");
+			return 1;
+		}
+		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.");
@@ -678,5 +743,3 @@ async function main() {
 if (isDirectExecution(import.meta.url)) main();
 //#endregion
 export { runSkillsCli as n, syncBundledSkills as r, installBundledSkills as t };
-
-//# sourceMappingURL=skills-Bh0mEhIx.js.map

package/dist/skills.d.ts

@@ -0,0 +1,18 @@
+//#region src/bin/skills.d.ts
+type CliIo = Pick<Console, "error" | "log">;
+declare function installBundledSkills(options?: {
+  cwd?: string;
+  force?: boolean;
+}): Promise<{
+  bundledNames: string[];
+  targetSkillsDir: string;
+}>;
+declare function syncBundledSkills(options?: {
+  cwd?: string;
+}): Promise<{
+  bundledNames: string[];
+  targetSkillsDir: string;
+}>;
+declare function runSkillsCli(args?: string[], io?: CliIo): Promise<number>;
+//#endregion
+export { installBundledSkills, runSkillsCli, syncBundledSkills };

package/dist/skills.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { n as runSkillsCli, r as syncBundledSkills, t as installBundledSkills } from "./skills-Bh0mEhIx.js";
+import { n as runSkillsCli, r as syncBundledSkills, t as installBundledSkills } from "./skills-B7CbWur9.js";
 export { installBundledSkills, runSkillsCli, syncBundledSkills };

package/dist/specification-DXnDOC-0.js

@@ -47,5 +47,3 @@ function parseDependencySpecification(specification) {
 }
 //#endregion
 export { parseDependencySpecification as t };
-
-//# sourceMappingURL=specification-DXnDOC-0.js.map

package/dist/ssg-config.d.ts

@@ -0,0 +1,41 @@
+//#region src/ssg/sitemap.d.ts
+type SitemapChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+interface SitemapRouteConfig {
+  /** Canonical URL. Relative values resolve against siteUrl. */
+  url?: string;
+  /** W3C date/datetime or Date describing the last meaningful page update. */
+  lastModified?: string | Date;
+  changeFrequency?: SitemapChangeFrequency;
+  /** Relative crawl priority from 0 through 1. */
+  priority?: number;
+  /** hreflang to canonical URL mapping, including optional x-default. */
+  alternates?: Readonly<Record<string, string>>;
+}
+interface SitemapRouteContext {
+  path: string;
+  filePath: string;
+  status: string;
+}
+interface SitemapConfig {
+  /** Site-wide values inherited by included routes. */
+  defaults?: Omit<SitemapRouteConfig, "url" | "alternates">;
+  /** Exact concrete route overrides. Set a route to false to exclude it. */
+  routes?: Readonly<Record<string, SitemapRouteConfig | false>>;
+  /** Compute or override sitemap data. Returning false excludes the route. */
+  resolve?: (route: SitemapRouteContext) => SitemapRouteConfig | false | null | undefined | Promise<SitemapRouteConfig | false | null | undefined>;
+  /** Output path relative to the SSG output directory. */
+  output?: string;
+  /** Maintain a Sitemap directive in robots.txt. Defaults to true. */
+  robots?: boolean | {
+    output?: string;
+  };
+  /** Optional lower limits for deterministic partitioning and tests. */
+  limits?: {
+    urlsPerFile?: number;
+    bytesPerFile?: number;
+  };
+  /** Maximum concurrent async route metadata resolvers. Defaults to 16. */
+  resolverConcurrency?: number;
+}
+//#endregion
+export type { SitemapChangeFrequency, SitemapConfig, SitemapRouteConfig, SitemapRouteContext };

package/dist/ssg-config.js

@@ -0,0 +1 @@
+export {};