@askrjs/cli 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askrjs/cli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Unified CLI for the Askr platform",
   "homepage": "https://github.com/askrjs/askr-cli#readme",
   "bugs": {
@@ -19,13 +19,15 @@
     "askr": "./dist/cli.js"
   },
   "files": [
-    "dist",
-    "skills",
-    "templates"
+    "dist"
   ],
   "type": "module",
   "exports": {
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./ssg": {
+      "types": "./dist/ssg-config.d.ts",
+      "import": "./dist/ssg-config.js"
+    }
   },
   "publishConfig": {
     "access": "public"
@@ -35,36 +37,35 @@
     "build": "vp pack",
     "dev": "vp pack --watch",
     "test": "vp test run -c vitest.config.ts",
+    "test:coverage": "vp test run -c vitest.config.ts --coverage",
     "fmt": "vp fmt .",
     "lint": "vp lint src tests vite.config.ts vitest.config.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test:publint": "publint",
     "pack:check": "npm pack --ignore-scripts --dry-run --json",
-    "check": "npm run lint && npm run typecheck && npm test && npm run build && npm run test:publint && npm run pack:check",
+    "test:templates": "node scripts/verify-packed-templates.mjs",
+    "check": "npm run lint && npm run typecheck && npm run test:coverage && npm run build && npm run test:publint && npm run pack:check",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run check"
+    "prepublishOnly": "npm run check && npm run test:templates"
   },
   "dependencies": {
-    "@npmcli/config": "^9.0.0",
-    "@npmcli/map-workspaces": "^4.0.2",
-    "jsonc-parser": "^3.3.1",
+    "js-yaml": "^4.3.0",
     "minimatch": "^10.2.5",
-    "npm-package-arg": "^13.0.2",
-    "npm-registry-fetch": "^19.1.1",
     "semver": "^7.8.5",
-    "tsx": "^4.23.1",
-    "yaml": "^2.9.0"
+    "tsx": "^4.23.1"
   },
   "devDependencies": {
-    "@askrjs/askr": "file:../askr",
-    "@askrjs/charts": "file:../askr-charts",
-    "@askrjs/logos": "file:../askr-logos",
-    "@askrjs/lucide": "file:../askr-lucide",
-    "@askrjs/themes": "file:../askr-themes",
-    "@askrjs/ui": "file:../askr-ui",
-    "@askrjs/vite": "file:../askr-vite",
-    "@types/node": "^25.9.2",
+    "@askrjs/askr": ">=0.0.53 <0.1.0",
+    "@askrjs/charts": ">=0.1.0 <0.2.0",
+    "@askrjs/logos": ">=0.0.3 <0.1.0",
+    "@askrjs/lucide": ">=0.0.3 <0.1.0",
+    "@askrjs/themes": ">=0.0.12 <0.1.0",
+    "@askrjs/ui": ">=0.0.13 <0.1.0",
+    "@askrjs/vite": ">=0.0.6 <0.1.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.19.43",
     "@types/semver": "^7.7.1",
+    "@vitest/coverage-v8": "^4.1.10",
     "publint": "^0.3.21",
     "typescript": "^6.0.3",
     "vite-plus": "^0.2.4",

package/dist/add-DqhqRzBQ.js

@@ -1,555 +0,0 @@
-import { t as isDirectExecution } from "./is-direct-execution-Cdlr-ZUl.js";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-//#region src/file-changes.ts
-async function remove(paths) {
-	await Promise.all(paths.map((filePath) => fs.rm(filePath, { force: true }).catch(() => void 0)));
-}
-async function restore(changes) {
-	let complete = true;
-	for (const change of [...changes].reverse()) try {
-		if (change.original === null) {
-			await fs.rm(change.filePath, { force: true });
-			continue;
-		}
-		const rollbackPath = path.join(path.dirname(change.filePath), `.${path.basename(change.filePath)}.askr-rollback-${randomUUID()}`);
-		await fs.writeFile(rollbackPath, change.original, {
-			flag: "wx",
-			mode: change.mode
-		});
-		await fs.rename(rollbackPath, change.filePath);
-	} catch {
-		complete = false;
-	}
-	return complete;
-}
-async function writeFileChanges(changes, options = {}) {
-	const ordered = [...changes].sort((left, right) => left.filePath.localeCompare(right.filePath));
-	if (new Set(ordered.map((change) => change.filePath)).size !== ordered.length) throw new Error("File changes contain duplicate target paths.");
-	const replace = options.replace ?? fs.rename;
-	const staged = [];
-	try {
-		for (const change of ordered) {
-			await fs.mkdir(path.dirname(change.filePath), { recursive: true });
-			const stat = await fs.stat(change.filePath).catch(() => null);
-			const original = stat ? await fs.readFile(change.filePath) : null;
-			const temporaryPath = path.join(path.dirname(change.filePath), `.${path.basename(change.filePath)}.askr-change-${randomUUID()}`);
-			const mode = stat?.mode ?? 420;
-			await fs.writeFile(temporaryPath, change.content, {
-				flag: "wx",
-				mode
-			});
-			staged.push({
-				...change,
-				original,
-				mode,
-				temporaryPath
-			});
-		}
-	} catch (error) {
-		await remove(staged.map((change) => change.temporaryPath));
-		throw error;
-	}
-	const replaced = [];
-	try {
-		for (const change of staged) {
-			await replace(change.temporaryPath, change.filePath);
-			replaced.push(change);
-		}
-	} catch {
-		const complete = await restore(replaced);
-		await remove(staged.map((change) => change.temporaryPath));
-		throw new Error(complete ? "File replacement failed; completed changes were rolled back." : "File replacement failed and rollback was incomplete.");
-	}
-}
-//#endregion
-//#region src/bin/add.ts
-const BRANCH_CONFIG = {
-	app: {
-		badge: "app route",
-		pagesDir: [
-			"src",
-			"pages",
-			"app"
-		],
-		routesFile: [
-			"src",
-			"pages",
-			"app",
-			"_routes.tsx"
-		]
-	},
-	public: {
-		badge: "public route",
-		pagesDir: [
-			"src",
-			"pages",
-			"public"
-		],
-		routesFile: [
-			"src",
-			"pages",
-			"public",
-			"_routes.tsx"
-		]
-	}
-};
-function helpText() {
-	return [
-		"askr add - Generate code into an existing Askr project",
-		"",
-		"Usage:",
-		"  askr add page <name> [--branch app|public] [--cwd <dir>] [--title <title>] [--route <path>] [--force]",
-		"  askr add action <name> --route <path> [--cwd <dir>] [--force]",
-		"",
-		"Commands:",
-		"  page      Scaffold a route page and register it in a route-first SPA branch",
-		"  action    Scaffold a browser descriptor, server handler, registration, authorization, and test",
-		"",
-		"Options:",
-		"  --branch <name>  Route branch to target (default: app)",
-		"  --cwd <dir>      Project directory (default: current directory)",
-		"  --title <text>   Override the generated page title",
-		"  --route <path>   Override the generated route path",
-		"  --force          Overwrite an existing page file",
-		"  --help           Show this help message",
-		"",
-		"Examples:",
-		"  askr add page audit-log",
-		"  askr add page ops/audit-log --branch public",
-		"  askr add page approvals --title \"Human approvals\" --route /app/approvals",
-		"  askr add action approve-request --route /requests/{id}",
-		"",
-		"Notes:",
-		"  Page generation supports route-first SPA projects created from `askr create spa`.",
-		"  Action generation supports projects created from `askr create full-stack`."
-	].join("\n");
-}
-function parseArgs(args) {
-	const positional = [];
-	const parsed = {
-		branch: "app",
-		cwd: process.cwd(),
-		force: false,
-		help: false,
-		routePath: "",
-		title: "",
-		errors: []
-	};
-	for (let index = 0; index < args.length; index += 1) {
-		const arg = args[index];
-		if (arg === "--help" || arg === "-h") parsed.help = true;
-		else if (arg === "--force") parsed.force = true;
-		else if (arg === "--branch") if (index + 1 >= args.length) parsed.errors.push("Missing value for --branch");
-		else {
-			parsed.branch = args[index + 1];
-			index += 1;
-		}
-		else if (arg === "--cwd") if (index + 1 >= args.length) parsed.errors.push("Missing value for --cwd");
-		else {
-			parsed.cwd = args[index + 1];
-			index += 1;
-		}
-		else if (arg === "--title") if (index + 1 >= args.length) parsed.errors.push("Missing value for --title");
-		else {
-			parsed.title = args[index + 1].trim();
-			index += 1;
-		}
-		else if (arg === "--route") if (index + 1 >= args.length) parsed.errors.push("Missing value for --route");
-		else {
-			parsed.routePath = args[index + 1].trim();
-			index += 1;
-		}
-		else positional.push(arg);
-	}
-	return {
-		...parsed,
-		command: positional[0] || "",
-		name: positional[1] || ""
-	};
-}
-async function pathExists(filePath) {
-	return Boolean(await fs.stat(filePath).catch(() => null));
-}
-function slugifySegment(value) {
-	return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function normalizePageSegments(input) {
-	const segments = input.replace(/^\/+|\/+$/g, "").split("/").map((segment) => slugifySegment(segment.trim())).filter(Boolean);
-	if (segments.length === 0 || segments.some((segment) => segment.startsWith("_"))) return [];
-	return segments;
-}
-function toWords(segments) {
-	return segments.flatMap((segment) => segment.split("-").filter(Boolean));
-}
-function toTitleCase(words) {
-	return words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-}
-function buildComponentName(segments) {
-	return `${toWords(segments).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("")}Page`;
-}
-function buildIdentifier(segments) {
-	const [first = "action", ...rest] = toWords(segments);
-	return [first.toLowerCase(), ...rest.map((word) => word.charAt(0).toUpperCase() + word.slice(1))].join("").replace(/^[^a-z_$]/i, "action");
-}
-function renderAuthorizationRegistry(actions) {
-	const imports = actions.map((action) => `import { ${action.descriptorName} } from './actions/${action.slug}.js';`);
-	const routes = /* @__PURE__ */ new Map();
-	for (const action of actions) {
-		const entries = routes.get(action.routePath) ?? [];
-		entries.push(action);
-		routes.set(action.routePath, entries);
-	}
-	const routeLines = [...routes].sort(([left], [right]) => left.localeCompare(right)).map(([routePath, entries]) => `  ${JSON.stringify(routePath)}: [${entries.map((entry) => entry.descriptorName).join(", ")}],`);
-	return [
-		"import type { ActionDescriptor } from '@askrjs/askr/actions';",
-		...imports,
-		"",
-		"const actionsByRoute: Readonly<Record<string, readonly ActionDescriptor[]>> = Object.freeze({",
-		...routeLines,
-		"});",
-		"",
-		"export function actionsFor(path: string): readonly ActionDescriptor[] {",
-		"  return actionsByRoute[path] ?? [];",
-		"}",
-		""
-	].join("\n");
-}
-function renderServerActionRegistry(actions) {
-	return [
-		"import { createActionRegistry } from '@askrjs/server/askr';",
-		...actions.map((action) => `import { ${action.descriptorName} } from '../actions/${action.slug}.js';`),
-		...actions.map((action) => `import { ${action.handlerName} } from './actions/${action.slug}.js';`),
-		"import type { AppDependencies } from './dependencies.js';",
-		"",
-		"export function createActions(deps: AppDependencies) {",
-		"  const registry = createActionRegistry(deps, {",
-		"    csrf: { secret: process.env.CSRF_SECRET ?? 'development-only-secret' },",
-		"  });",
-		...actions.map((action) => `  registry.register(${action.descriptorName}, ${action.handlerName});`),
-		"  return registry;",
-		"}",
-		""
-	].join("\n");
-}
-async function discoverDeclaredActions(projectRoot, replacement) {
-	const actionsDir = path.join(projectRoot, "src", "actions");
-	const names = await fs.readdir(actionsDir).catch(() => []);
-	const files = new Set(names.filter((name) => name.endsWith(".ts")).map((name) => path.join(actionsDir, name)));
-	files.add(replacement.filePath);
-	const actions = [];
-	for (const filePath of [...files].sort()) {
-		const content = filePath === replacement.filePath ? replacement.content : await fs.readFile(filePath, "utf8");
-		const descriptor = /export const (\w+Action) = defineAction\(/.exec(content)?.[1];
-		if (!descriptor) continue;
-		const routeName = `${descriptor}Route`;
-		const routeMatch = new RegExp(`export const ${routeName} = (['"])(.*?)\\1;`).exec(content);
-		if (!routeMatch) throw new Error(`Action descriptor ${path.basename(filePath)} must declare ${routeName}.`);
-		const slug = path.basename(filePath, ".ts");
-		actions.push({
-			slug,
-			descriptorName: descriptor,
-			handlerName: buildIdentifier([slug]),
-			routePath: routeMatch[2]
-		});
-	}
-	return actions.sort((left, right) => left.slug.localeCompare(right.slug));
-}
-function renderActionDescriptor(options) {
-	return [
-		"import { defineAction } from '@askrjs/askr/actions';",
-		"import { schema } from '@askrjs/schema';",
-		"",
-		`export const ${options.descriptorName}Route = ${JSON.stringify(options.routePath)};`,
-		"",
-		`export const ${options.descriptorName} = defineAction({`,
-		`  id: '${options.slug}',`,
-		"  input: schema.object({ value: schema.string({ minLength: 1 }) }),",
-		"  invalidates: [],",
-		"});",
-		""
-	].join("\n");
-}
-function renderActionHandler(options) {
-	return [
-		"import type { InferSchema } from '@askrjs/schema';",
-		`import { ${options.descriptorName} } from '../../actions/${options.slug}.js';`,
-		"import type { AppDependencies } from '../dependencies.js';",
-		"",
-		`type Input = InferSchema<typeof ${options.descriptorName}.input>;`,
-		"",
-		`export async function ${options.handlerName}(`,
-		"  _context: unknown,",
-		"  input: Input,",
-		"  deps: Pick<AppDependencies, 'actions'>,",
-		") {",
-		"  await deps.actions.record({ action: " + JSON.stringify(options.slug) + ", value: input.value });",
-		"  return { result: { accepted: true } };",
-		"}",
-		""
-	].join("\n");
-}
-function renderActionTest(options) {
-	return [
-		"import { describe, expect, it } from 'vitest';",
-		`import { ${options.descriptorName} } from '../../src/actions/${options.slug}.js';`,
-		"",
-		`describe('${options.slug} action', () => {`,
-		"  it('should expose a browser-safe executable input contract', () => {",
-		`    expect(${options.descriptorName}.id).toBe('${options.slug}');`,
-		`    expect(${options.descriptorName}.input.safeParse({ value: 'example' }).success).toBe(true);`,
-		`    expect(${options.descriptorName}.input.safeParse({ value: '' }).success).toBe(false);`,
-		"  });",
-		"});",
-		""
-	].join("\n");
-}
-function buildRoutePath(branch, segments, overridePath = "") {
-	if (!overridePath) {
-		const suffix = segments.join("/");
-		return branch === "app" ? `/app/${suffix}` : `/${suffix}`;
-	}
-	const normalized = overridePath.startsWith("/") ? overridePath : `/${overridePath}`;
-	if (branch === "app") return normalized === "/app" || normalized.startsWith("/app/") ? normalized : `/app${normalized}`;
-	if (normalized === "/app" || normalized.startsWith("/app/")) throw new Error("Public branch routes cannot live under /app.");
-	return normalized;
-}
-function toImportSpecifier(fromFile, toFile) {
-	const withoutExtension = path.relative(path.dirname(fromFile), toFile).replace(/\\/g, "/").replace(/\.tsx$/i, "");
-	return withoutExtension.startsWith(".") ? withoutExtension : `./${withoutExtension}`;
-}
-function createUpdatedRouteFile(routeFileContent, options) {
-	const normalized = routeFileContent.replace(/\r\n/g, "\n");
-	const lines = normalized.split("\n");
-	const lastImportIndex = lines.reduce((currentIndex, line, index) => line.startsWith("import ") ? index : currentIndex, -1);
-	if (lastImportIndex === -1) throw new Error("Unsupported route file: could not find import block.");
-	const importLine = `import ${options.componentName} from '${options.importSpecifier}';`;
-	if (normalized.includes(importLine) || normalized.includes(`route('${options.routePath}',`) || normalized.includes(`route("${options.routePath}",`)) throw new Error(`Route '${options.routePath}' is already registered.`);
-	lines.splice(lastImportIndex + 1, 0, importLine);
-	const closingIndex = lines.map((line) => line.trim()).lastIndexOf("}");
-	if (closingIndex === -1) throw new Error("Unsupported route file: could not find registration function body.");
-	lines.splice(closingIndex, 0, `  route('${options.routePath}', ${options.componentName});`);
-	return `${lines.join("\n")}\n`;
-}
-function renderPageFile(options) {
-	return [
-		"import {",
-		"  Badge,",
-		"  Card,",
-		"  CardContent,",
-		"  CardDescription,",
-		"  CardHeader,",
-		"  CardTitle,",
-		"} from '@askrjs/themes/components';",
-		"import { Stack } from '@askrjs/themes/components';",
-		"",
-		`export default function ${options.componentName}() {`,
-		"  return (",
-		"    <Stack gap=\"5\">",
-		"      <section class=\"page-heading\">",
-		"        <Stack gap=\"2\">",
-		`          <Badge>${options.badge}</Badge>`,
-		`          <h1>${options.title}</h1>`,
-		"          <p class=\"lead\">",
-		`            Route-first scaffold for ${options.routePath}. Keep adapters, queries, and mutations outside the page as this surface grows.`,
-		"          </p>",
-		"        </Stack>",
-		"      </section>",
-		"",
-		"      <Card>",
-		"        <CardHeader>",
-		"          <CardTitle>Next step</CardTitle>",
-		"          <CardDescription>",
-		"            Move view logic into feature folders and keep loading, empty, error, and success states explicit.",
-		"          </CardDescription>",
-		"        </CardHeader>",
-		"        <CardContent>",
-		"          <Stack gap=\"3\">",
-		"            <p>Start with a focused feature boundary instead of inline data fetching.</p>",
-		"            <p>Prefer resource(), derive(), and For once the page takes on real state.</p>",
-		"          </Stack>",
-		"        </CardContent>",
-		"      </Card>",
-		"    </Stack>",
-		"  );",
-		"}",
-		""
-	].join("\n");
-}
-async function addPage(parsed, io) {
-	if (!parsed.name) {
-		io.error("Page name is required.");
-		return 1;
-	}
-	const branch = parsed.branch.toLowerCase();
-	const branchConfig = BRANCH_CONFIG[branch];
-	if (!branchConfig) {
-		io.error(`Unsupported branch '${parsed.branch}'. Use app or public.`);
-		return 1;
-	}
-	const segments = normalizePageSegments(parsed.name);
-	if (segments.length === 0) {
-		io.error("Page name must contain at least one non-empty path segment.");
-		return 1;
-	}
-	const projectRoot = path.resolve(parsed.cwd);
-	const routesFile = path.join(projectRoot, ...branchConfig.routesFile);
-	if (!await pathExists(routesFile)) {
-		io.error(`Unsupported project layout. Expected route file: ${routesFile}`);
-		io.error("askr add page currently supports route-first SPA projects created by `askr create spa`.");
-		return 1;
-	}
-	const pageFile = path.join(projectRoot, ...branchConfig.pagesDir, ...segments).concat(".tsx");
-	if (await pathExists(pageFile) && !parsed.force) {
-		io.error(`Page file already exists: ${pageFile}`);
-		io.error("Pass --force to overwrite the existing file.");
-		return 1;
-	}
-	const title = parsed.title || toTitleCase(toWords(segments));
-	const componentName = buildComponentName(segments);
-	let routePath = "";
-	try {
-		routePath = buildRoutePath(branch, segments, parsed.routePath);
-	} catch (error) {
-		io.error(error instanceof Error ? error.message : String(error));
-		return 1;
-	}
-	const importSpecifier = toImportSpecifier(routesFile, pageFile);
-	let updatedRoutes = "";
-	try {
-		updatedRoutes = createUpdatedRouteFile(await fs.readFile(routesFile, "utf8"), {
-			componentName,
-			importSpecifier,
-			routePath
-		});
-	} catch (error) {
-		io.error(error instanceof Error ? error.message : String(error));
-		return 1;
-	}
-	try {
-		await fs.mkdir(path.dirname(pageFile), { recursive: true });
-		await fs.writeFile(pageFile, renderPageFile({
-			badge: branchConfig.badge,
-			componentName,
-			routePath,
-			title
-		}), "utf8");
-		await fs.writeFile(routesFile, updatedRoutes, "utf8");
-	} catch (error) {
-		io.error("Failed to write generated page artifacts.");
-		io.error(error instanceof Error ? error.message : String(error));
-		return 1;
-	}
-	io.log(`Added ${branch} page '${title}'.`);
-	io.log(`  File: ${path.relative(projectRoot, pageFile).replace(/\\/g, "/")}`);
-	io.log(`  Route: ${routePath}`);
-	io.log(`  Router: ${path.relative(projectRoot, routesFile).replace(/\\/g, "/")}`);
-	return 0;
-}
-async function addAction(parsed, io) {
-	if (!parsed.name) {
-		io.error("Action name is required.");
-		return 1;
-	}
-	if (!parsed.routePath || !parsed.routePath.startsWith("/")) {
-		io.error("Action generation requires an absolute --route path.");
-		return 1;
-	}
-	const segments = normalizePageSegments(parsed.name);
-	if (segments.length === 0) {
-		io.error("Action name must contain at least one non-empty path segment.");
-		return 1;
-	}
-	const projectRoot = path.resolve(parsed.cwd);
-	const slug = segments.join("-");
-	const handlerName = buildIdentifier(segments);
-	const descriptorName = `${handlerName}Action`;
-	const descriptorFile = path.join(projectRoot, "src", "actions", `${slug}.ts`);
-	const handlerFile = path.join(projectRoot, "src", "server", "actions", `${slug}.ts`);
-	const registryFile = path.join(projectRoot, "src", "server", "action-registry.ts");
-	const authorizationFile = path.join(projectRoot, "src", "action-authorizations.ts");
-	const testFile = path.join(projectRoot, "tests", "actions", `${slug}.test.ts`);
-	if (!await pathExists(registryFile) || !await pathExists(authorizationFile)) {
-		io.error("Unsupported project layout. Expected an `askr create full-stack` project.");
-		return 1;
-	}
-	if (!parsed.force && (await pathExists(descriptorFile) || await pathExists(handlerFile))) {
-		io.error(`Action '${slug}' already exists. Pass --force to replace its generated files.`);
-		return 1;
-	}
-	try {
-		const descriptor = renderActionDescriptor({
-			descriptorName,
-			routePath: parsed.routePath,
-			slug
-		});
-		const actions = await discoverDeclaredActions(projectRoot, {
-			filePath: descriptorFile,
-			content: descriptor
-		});
-		await writeFileChanges([
-			{
-				filePath: descriptorFile,
-				content: descriptor
-			},
-			{
-				filePath: handlerFile,
-				content: renderActionHandler({
-					descriptorName,
-					handlerName,
-					slug
-				})
-			},
-			{
-				filePath: testFile,
-				content: renderActionTest({
-					descriptorName,
-					slug
-				})
-			},
-			{
-				filePath: registryFile,
-				content: renderServerActionRegistry(actions)
-			},
-			{
-				filePath: authorizationFile,
-				content: renderAuthorizationRegistry(actions)
-			}
-		]);
-	} catch (error) {
-		io.error("Failed to write generated action artifacts.");
-		io.error(error instanceof Error ? error.message : String(error));
-		return 1;
-	}
-	io.log(`Added action '${slug}' for ${parsed.routePath}.`);
-	io.log(`  Descriptor: ${path.relative(projectRoot, descriptorFile).replace(/\\/g, "/")}`);
-	io.log(`  Handler: ${path.relative(projectRoot, handlerFile).replace(/\\/g, "/")}`);
-	io.log(`  Test: ${path.relative(projectRoot, testFile).replace(/\\/g, "/")}`);
-	return 0;
-}
-async function runAddCli(args = process.argv.slice(2), io = console) {
-	const parsed = parseArgs(args);
-	if (parsed.errors.length > 0) {
-		for (const message of parsed.errors) io.error(message);
-		return 1;
-	}
-	if (!parsed.command || parsed.help) {
-		io.log(helpText());
-		return 0;
-	}
-	if (parsed.command === "page") return addPage(parsed, io);
-	if (parsed.command === "action") return addAction(parsed, io);
-	io.error(`Unknown add command: ${parsed.command}`);
-	io.error("Run `askr add --help` to see available commands.");
-	return 1;
-}
-async function main() {
-	const code = await runAddCli(process.argv.slice(2));
-	process.exit(code);
-}
-if (isDirectExecution(import.meta.url)) main();
-//#endregion
-export { runAddCli as t };
-
-//# sourceMappingURL=add-DqhqRzBQ.js.map