@askrjs/cli 0.0.15 → 0.0.17

package/README.md

@@ -45,11 +45,12 @@ unless you opt out with `--no-skills`.
 - `askr doctor [--cwd <dir>] [--workspace <pattern>]... [--json]`
 - `askr repair [--cwd <dir>] [--workspace <pattern>]... [--json]`
 - `askr check [--cwd <dir>] [--workspace <pattern>]... [--json]`
+- `askr database validate|generate [--database <name>] [--json]`
+- `askr database migration create|status|plan|apply|resolve ...`
 - `askr skills list`
 - `askr skills install [--cwd <dir>] [--force]`
 - `askr skills sync [--cwd <dir>]`
 - `askr ssg --config <path> --output <dir> [--incremental]`
-- `askr verify-hydration [--output ./dist] [--route <path>]...`
 - `askr openapi [--entry ./src/api.ts] [--output ./openapi.yml] [--check]`
 - `askr outdated [packages...] [--workspace <glob>] [--tag <tag>] [--json]`
 - `askr update [packages...] [--workspace <glob>] [--tag <tag>] [--json]`
@@ -74,10 +75,8 @@ askr analyze --json --check
 
 All diagnostics include a stable rule ID and workspace-relative source
 location. The analyzer distinguishes canonical Askr imports from unrelated
-same-named functions and recommends `<For>` only when a `.map()` result is
-rendered directly as JSX children, so ordinary data transforms remain valid.
-It reports eager `<For>`/`<Show>`/`<Case>` controls behind changing ternaries
-while accepting conditionally mounted components with their own render scope.
+same-named functions and only recommends `<For>` for state-backed reactive JSX
+collections, so static transforms with `.map()` remain valid.
 
 By default it transactionally applies only mechanical route-parameter and
 plain-JSON JSX configuration fixes. `--check` is read-only for CI. Semantic
@@ -99,7 +98,17 @@ askr check
 and static-analysis inspection. `repair` transactionally applies only safe
 mechanical fixes and reports remaining semantic work. `check` requires clean
 analysis before running the project's declared lint, typecheck, test, and build
-scripts in order. Generated projects expose that final gate as `npm run check`.
+scripts in order. When `database/index.ts` exists, `check` first delegates
+database validation to the project's installed `@askrjs/orm` tooling.
+Generated projects expose that final gate as `npm run check`.
+
+## Database tooling
+
+`askr database ...` is a lazy front end. The CLI resolves
+`@askrjs/orm/tooling` from the target project and delegates the complete
+command, so schema generation and migration semantics always match the
+project's installed ORM version. See the
+[database command reference](./docs/database.md).
 
 See the [project guardrails reference](./docs/guardrails.md) for command and JSON
 contracts.
@@ -141,24 +150,6 @@ owned files so stale chunks and previous output paths are removed. Full and
 incremental builds publish through a sibling staging directory, so route output,
 metadata, assets, and sitemap artifacts change together or not at all.
 
-## Hydration verification
-
-`askr verify-hydration` builds SSG output, serves the generated route set, and
-loads every successful metadata route in a real headless browser both with and
-without JavaScript. It compares normalized tag-and-child topology under `#app`
-after hydration, so text, classes, and mutable ARIA state do not create noise
-while nodes migrating into the wrong sibling container fail with an actionable
-static-versus-hydrated path diff.
-
-```bash
-askr verify-hydration
-askr verify-hydration --route / --route /docs
-askr verify-hydration --no-build --output ./dist
-```
-
-See the [hydration verification reference](./docs/verify-hydration.md) for
-browser installation, timeout, route, and root-selector options.
-
 ## OpenAPI artifacts
 
 `askr openapi` loads a TypeScript module whose default export exposes

package/dist/analyze.js

@@ -71,7 +71,7 @@ async function runAnalyzeCli(args = process.argv.slice(2), io = console, runtime
 			io.log(helpText.trimEnd());
 			return 0;
 		}
-		const report = await (runtime.analyze ?? (await import("./runner-BSs9Ow3t.js")).runAnalysis)({
+		const report = await (runtime.analyze ?? (await import("./runner-SJnfoNvK.js")).runAnalysis)({
 			cwd: parsed.cwd,
 			workspacePatterns: parsed.workspacePatterns,
 			check: parsed.check

package/dist/cli.js

@@ -36,12 +36,12 @@ function printHelp(io = console) {
 	io.log("  analyze    Analyze Askr correctness and performance");
 	io.log("  check      Run the complete project validation path");
 	io.log("  create     Create a new Askr app from a template or product prompt");
+	io.log("  database   Generate, validate, and migrate project databases");
 	io.log("  doctor     Diagnose environment and Askr project health");
 	io.log("  generate   Generate an @askrjs/fetch client from OpenAPI");
 	io.log("  openapi    Generate or check an OpenAPI YAML artifact");
 	io.log("  skills     Install or sync Askr agent skills");
 	io.log("  ssg        Run static-site generation");
-	io.log("  verify-hydration  Verify SSG DOM structure in a real browser");
 	io.log("  outdated   List available dependency updates");
 	io.log("  repair     Apply safe fixes and identify remaining semantic work");
 	io.log("  update     Apply safe dependency updates");
@@ -60,11 +60,11 @@ function printHelp(io = console) {
 	io.log("  askr doctor");
 	io.log("  askr repair");
 	io.log("  askr check");
+	io.log("  askr database validate");
 	io.log("  askr skills install");
 	io.log("  askr openapi --check");
 	io.log("  askr skills review foundation --cwd ./candidate-app");
 	io.log("  askr ssg --config ./ssg.config.ts --output ./dist/static");
-	io.log("  askr verify-hydration --output ./dist --route /");
 	io.log("  askr outdated");
 	io.log("  askr update");
 	io.log("  askr upgrade");
@@ -87,12 +87,16 @@ async function runCli(args = process.argv.slice(2), io = console) {
 		const { runAddCli } = await import("./add.js");
 		return runAddCli(args.slice(1), io);
 	}
+	if (command === "database") {
+		const { runDatabaseCommand } = await import("./database.js");
+		return runDatabaseCommand(args.slice(1), io);
+	}
 	if (command === "analyze") {
 		const { runAnalyzeCli } = await import("./analyze.js");
 		return runAnalyzeCli(args.slice(1), io);
 	}
 	if (command === "check" || command === "doctor" || command === "repair") {
-		const { runGuardrailCli } = await import("./guardrails-D6KCKS-H.js");
+		const { runGuardrailCli } = await import("./guardrails-Dq4-Rglh.js");
 		return runGuardrailCli(command, args.slice(1), io);
 	}
 	if (command === "generate") {
@@ -103,10 +107,6 @@ async function runCli(args = process.argv.slice(2), io = console) {
 		const { runSsgCli } = await import("./ssg.js");
 		return runSsgCli(args.slice(1), void 0, io);
 	}
-	if (command === "verify-hydration") {
-		const { runVerifyHydrationCli } = await import("./verify-hydration.js");
-		return runVerifyHydrationCli(args.slice(1), void 0, io);
-	}
 	if (command === "openapi") {
 		const { runOpenApiCli } = await import("./openapi.js");
 		return runOpenApiCli(args.slice(1), io);

package/dist/database.d.ts

@@ -0,0 +1,18 @@
+//#region src/bin/database.d.ts
+type CliIo = Pick<Console, "error" | "log">;
+interface OrmTooling {
+  runDatabaseCli(args: readonly string[], options: {
+    readonly cwd: string;
+    readonly io: CliIo;
+  }): Promise<number>;
+}
+declare function loadOrmTooling(cwd: string): Promise<OrmTooling>;
+declare function runDatabaseCommand(args: readonly string[], io?: CliIo, cwd?: string, loader?: (cwd: string) => Promise<OrmTooling>): Promise<number>;
+declare function runDatabaseValidation(cwd: string, loader?: (cwd: string) => Promise<OrmTooling>): Promise<{
+  readonly status: "passed" | "failed";
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+}>;
+//#endregion
+export { OrmTooling, loadOrmTooling, runDatabaseCommand, runDatabaseValidation };

package/dist/database.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/bin/database.ts
+async function loadOrmTooling(cwd) {
+	const require = createRequire(path.join(path.resolve(cwd), "package.json"));
+	let entry;
+	try {
+		const manifestPath = require.resolve("@askrjs/orm/package.json");
+		const toolingExport = JSON.parse(await fs.readFile(manifestPath, "utf8")).exports?.["./tooling"];
+		const relative = typeof toolingExport === "string" ? toolingExport : toolingExport?.import;
+		if (!relative) throw new Error("Missing import export for @askrjs/orm/tooling.");
+		entry = path.resolve(path.dirname(manifestPath), relative);
+	} catch (error) {
+		throw new Error("This project does not have @askrjs/orm installed. Install it before running `askr database`.", { cause: error });
+	}
+	const tooling = await import(pathToFileURL(entry).href);
+	if (typeof tooling.runDatabaseCli !== "function") throw new Error("The installed @askrjs/orm package does not expose compatible database tooling.");
+	return tooling;
+}
+async function runDatabaseCommand(args, io = console, cwd = process.cwd(), loader = loadOrmTooling) {
+	try {
+		return (await loader(cwd)).runDatabaseCli(args, {
+			cwd,
+			io
+		});
+	} catch (error) {
+		io.error(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
+async function runDatabaseValidation(cwd, loader = loadOrmTooling) {
+	const stdout = [];
+	const stderr = [];
+	const code = await runDatabaseCommand([
+		"validate",
+		"--cwd",
+		cwd
+	], {
+		log: (...values) => stdout.push(values.join(" ")),
+		error: (...values) => stderr.push(values.join(" "))
+	}, cwd, loader);
+	return {
+		status: code === 0 ? "passed" : "failed",
+		exitCode: code,
+		stdout: stdout.join("\n"),
+		stderr: stderr.join("\n")
+	};
+}
+//#endregion
+export { loadOrmTooling, runDatabaseCommand, runDatabaseValidation };

package/dist/generate.js

@@ -1,5 +1,5 @@
 import { mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { lookup } from "node:dns/promises";
 import { request } from "node:https";
@@ -296,10 +296,16 @@ async function fetchSource(uri, options) {
 }
 async function readSource(uri, options) {
 	if (uri.startsWith("http://") || uri.startsWith("https://")) return fetchSource(uri, options);
-	const path = fileURLToPath(uri);
+	let path;
+	try {
+		path = fileURLToPath(uri);
+	} catch {
+		throw new GenerationError(`Local OpenAPI reference escapes the specification directory: ${uri}`);
+	}
 	const canonical = await realpath(path);
-	const relativePath = options.localRootDirectory ? relative(options.localRootDirectory, canonical) : "..";
-	if (!options.localRootDirectory || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) throw new GenerationError(`Local OpenAPI reference escapes the specification directory: ${path}`);
+	if (!options.localRootDirectory) throw new GenerationError(`Local OpenAPI reference escapes the specification directory: ${path}`);
+	const relativePath = relative(options.localRootDirectory, canonical);
+	if (relativePath.startsWith("..") || isAbsolute(relativePath)) throw new GenerationError(`Local OpenAPI reference escapes the specification directory: ${path}`);
 	const contents = await readFile(canonical);
 	if (contents.byteLength > options.maxBytes) throw new GenerationError(`OpenAPI reference exceeds ${options.maxBytes} bytes: ${path}`);
 	return {

package/dist/{guardrails-D6KCKS-H.js → guardrails-Dq4-Rglh.js}

@@ -98,7 +98,7 @@ async function runGuardrailCli(command, args = process.argv.slice(2), io = conso
 			cwd: parsed.cwd,
 			workspacePatterns: parsed.workspacePatterns
 		};
-		const { runCheck, runDoctor, runRepair } = await import("./runner-DetGSvGf.js");
+		const { runCheck, runDoctor, runRepair } = await import("./runner-H-TW4lHZ.js");
 		const report = command === "doctor" ? await runDoctor(options, runtime) : command === "repair" ? await runRepair(options) : await runCheck(options, runtime);
 		if (parsed.json) io.log(JSON.stringify(report));
 		else if (report.command === "doctor") printDoctor(report, io);

package/dist/{planner-BEfWRd0x.js → planner-CYi2Y-2W.js}

@@ -294,11 +294,7 @@ function solveWorkspace(workspace, selectedOccurrences, context, packuments, tag
 				return;
 			}
 			const next = remaining.map((name) => [name, pruned.get(name)]).sort(([leftName, left], [rightName, right]) => left.length - right.length || leftName.localeCompare(rightName))[0];
-			const signature = component.map((name) => {
-				const assignedVersion = assigned.get(name);
-				const domain = pruned.get(name) ?? [];
-				return `${name}:assigned=${JSON.stringify(assignedVersion ?? null)}:domain=${JSON.stringify(domain)}`;
-			}).join("|");
+			const signature = component.map((name) => assigned.has(name) ? `${name}=assigned:${assigned.get(name)}` : `${name}=domain:${(pruned.get(name) ?? []).join(",")}`).join("|");
 			if (memo.has(signature)) return;
 			memo.add(signature);
 			for (const version of next[1]) {

package/dist/{runner-DetGSvGf.js → runner-H-TW4lHZ.js}

@@ -1,6 +1,6 @@
 import { t as inspectBundledSkills } from "./skills-CSGdAZHN.js";
 import { discoverWorkspaceProject } from "./discovery-DUDrZCIC.js";
-import { analysisHasBlockingFindings, runAnalysis } from "./runner-BSs9Ow3t.js";
+import { analysisHasBlockingFindings, runAnalysis } from "./runner-SJnfoNvK.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
@@ -229,16 +229,38 @@ async function runCheck(options, runtime = {}) {
 	const selected = VALIDATION_SCRIPTS.filter((name) => scripts[name]);
 	const manager = managerCommand(await existingLockfiles(project.root), rootWorkspace.manifest);
 	const results = [];
-	if (analysisHasBlockingFindings(analysis)) for (const name of selected) results.push({
+	const selectedChecks = [...Boolean(await fs.stat(path.join(project.root, "database", "index.ts")).catch(() => null)) ? ["database"] : [], ...selected];
+	if (analysisHasBlockingFindings(analysis)) for (const name of selectedChecks) results.push({
 		name,
 		status: "skipped",
-		command: `${manager.executable} run ${name}`,
+		command: name === "database" ? "askr database validate" : `${manager.executable} run ${name}`,
 		exitCode: null,
 		stdout: "",
 		stderr: "",
 		reason: "static analysis must pass first"
 	});
-	else for (const [index, name] of selected.entries()) {
+	else for (const [index, name] of selectedChecks.entries()) {
+		if (name === "database") {
+			const result = await (runtime.runDatabaseValidation ?? (await import("./database.js")).runDatabaseValidation)(project.root);
+			results.push({
+				name,
+				command: "askr database validate",
+				...result
+			});
+			if (result.status === "failed") {
+				for (const skipped of selectedChecks.slice(index + 1)) results.push({
+					name: skipped,
+					status: "skipped",
+					command: `${manager.executable} run ${skipped}`,
+					exitCode: null,
+					stdout: "",
+					stderr: "",
+					reason: "database validation failed"
+				});
+				break;
+			}
+			continue;
+		}
 		const args = manager.args(name);
 		const result = await (runtime.runScript ?? defaultRunScript)(manager.executable, args, project.root);
 		results.push({
@@ -247,7 +269,7 @@ async function runCheck(options, runtime = {}) {
 			...result
 		});
 		if (result.status === "failed") {
-			for (const skipped of selected.slice(index + 1)) results.push({
+			for (const skipped of selectedChecks.slice(index + 1)) results.push({
 				name: skipped,
 				status: "skipped",
 				command: `${manager.executable} run ${skipped}`,