@askrjs/cli 0.0.3 → 0.0.5

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 {};

package/dist/ssg.d.ts

@@ -0,0 +1,61 @@
+import { existsSync } from "node:fs";
+//#region src/bin/ssg.d.ts
+type CliIo = Pick<Console, "error" | "log">;
+interface ParsedSsgArgs {
+  configPath: string;
+  outputDir: string;
+  workers: number | "auto";
+  incremental: boolean;
+  changedKeys: string[];
+  changedRoutes: string[];
+  forceFull: boolean;
+  help: boolean;
+  errors: string[];
+}
+interface RouteResult {
+  path: string;
+  filePath: string;
+  status: string;
+  error?: string;
+}
+interface GenerateResult {
+  mode: string;
+  successful: number;
+  totalRoutes: number;
+  failed: number;
+  rebuilt: number;
+  skipped: number;
+  removed: number;
+  cacheHits: number;
+  routes: RouteResult[];
+}
+interface StaticGen {
+  generate(options: ReturnType<typeof toGenerateOptions>): Promise<GenerateResult>;
+}
+interface SsgDeps {
+  cwd?: () => string;
+  now?: () => number;
+  existsSync?: typeof existsSync;
+  importConfig?: (filePath: string) => Promise<unknown>;
+  createStaticGen?: (options: {
+    routes?: unknown[];
+    registry?: unknown;
+    outputDir: string;
+    seed?: unknown;
+    dataOverrides?: unknown;
+    concurrency?: number;
+    parallelism: number | "auto";
+    document?: unknown;
+    assets?: unknown[];
+  }) => StaticGen;
+}
+declare function parseCliArgs(args: string[]): ParsedSsgArgs;
+declare function toGenerateOptions(args: ParsedSsgArgs): {
+  mode: string;
+  changedKeys: string[];
+  changedRoutes: string[];
+  forceFull: boolean;
+};
+declare function runSsgCli(args?: string[], deps?: SsgDeps, io?: CliIo): Promise<number>;
+//#endregion
+export { parseCliArgs, runSsgCli };