@sansavision/aurora 0.1.0-alpha.20260212.4

package/test/analyze.test.ts

@@ -0,0 +1,301 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { runAnalyzeCommand } from "../src";
+
+const projectRoot = join(import.meta.dir, "..");
+
+function fixturePath(name: string): string {
+  return join("test/fixtures/analyze", name);
+}
+
+function readFixture(name: string): string {
+  return readFileSync(join(import.meta.dir, "fixtures/analyze", name), "utf8");
+}
+
+describe("runAnalyzeCommand", () => {
+  it("generates a bundle-mode text report", () => {
+    const result = runAnalyzeCommand([], { cwd: projectRoot });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("aurora analyze bundle report");
+    expect(result.stdout).toContain("out_dir: .aurora/analyze/compiler");
+    expect(result.stdout).toContain("manifest_found: false");
+  });
+
+  it("supports bundle-mode json output", () => {
+    const result = runAnalyzeCommand(["--format", "json"], { cwd: projectRoot });
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      outDir?: string;
+      manifestFound?: boolean;
+    };
+
+    expect(parsed.mode).toBe("bundle");
+    expect(parsed.outDir).toBe(".aurora/analyze/compiler");
+    expect(parsed.manifestFound).toBe(false);
+  });
+
+  it("loads compiler manifest data when --out-dir contains manifest.json", () => {
+    const result = runAnalyzeCommand(
+      ["--out-dir", "test/fixtures/analyze/compiler-manifest", "--format", "json"],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      manifestFound?: boolean;
+      routeCount?: number;
+      chunkCount?: number;
+      note?: string;
+    };
+
+    expect(parsed.mode).toBe("bundle");
+    expect(parsed.manifestFound).toBe(true);
+    expect(parsed.routeCount).toBe(3);
+    expect(parsed.chunkCount).toBe(2);
+    expect(parsed.note).toBe("manifest loaded");
+  });
+
+  it("supports cache mode for schemaVersion 1 fixtures", () => {
+    const inputPath = fixturePath("cache-input.v1.json");
+    const result = runAnalyzeCommand(
+      ["--mode", "cache", "--input", inputPath, "--format", "json"],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      entries?: number;
+    };
+    expect(parsed.mode).toBe("cache");
+    expect(parsed.entries).toBe(1);
+  });
+
+  it("supports realtime mode for schemaVersion 1 fixtures", () => {
+    const inputPath = fixturePath("realtime-input.v1.json");
+    const result = runAnalyzeCommand(["--mode", "realtime", "--input", inputPath], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("aurora analyze realtime report");
+    expect(result.stdout).toContain("lag_p95_ms: 260");
+  });
+
+  it("supports query mode for schemaVersion 1 fixtures", () => {
+    const inputPath = fixturePath("query-input.v1.json");
+    const result = runAnalyzeCommand(["--mode", "query", "--input", inputPath, "--format", "json"], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      samples?: number;
+    };
+    expect(parsed.mode).toBe("query");
+    expect(parsed.samples).toBe(2);
+  });
+
+  it("supports guardrails mode for schemaVersion 1 fixtures", () => {
+    const inputPath = fixturePath("guardrails-input.v1.json");
+    const result = runAnalyzeCommand(
+      ["--mode", "guardrails", "--input", inputPath, "--format", "json"],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      status?: string;
+      summary?: { total?: number; warnings?: number; errors?: number };
+      issues?: Array<{ code?: string }>;
+    };
+
+    expect(parsed.mode).toBe("guardrails");
+    expect(parsed.status).toBe("error");
+    expect(parsed.summary?.total).toBe(5);
+    expect(parsed.summary?.warnings).toBe(4);
+    expect(parsed.summary?.errors).toBe(1);
+    expect(parsed.issues?.some((issue) => issue.code === "PERF_PAYLOAD_ERROR")).toBe(true);
+  });
+
+  it("returns exit code 2 for invalid options", () => {
+    const result = runAnalyzeCommand(["--format", "xml"], { cwd: projectRoot });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("aurora analyze: invalid format 'xml'");
+  });
+
+  it("requires --input for non-bundle modes", () => {
+    const result = runAnalyzeCommand(["--mode", "cache"], { cwd: projectRoot });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain(
+      "aurora analyze: --input is required when --mode is cache, realtime, query, or guardrails",
+    );
+  });
+
+  it("rejects --out-dir when non-bundle mode is selected", () => {
+    const result = runAnalyzeCommand(
+      ["--mode", "query", "--input", fixturePath("query-input.v1.json"), "--out-dir", "dist/compiler"],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("aurora analyze: --out-dir is only valid when --mode is bundle");
+  });
+
+  it("rejects --input when bundle mode is selected", () => {
+    const result = runAnalyzeCommand(["--mode", "bundle", "--input", fixturePath("cache-input.v1.json")], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain(
+      "aurora analyze: --input is only valid when --mode is cache, realtime, query, or guardrails",
+    );
+  });
+
+  it("returns readable errors for invalid json input in non-bundle modes", () => {
+    const inputPath = fixturePath("cache-input.invalid.json");
+    const result = runAnalyzeCommand(["--mode", "cache", "--input", inputPath], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain(`aurora analyze: invalid json input at ${inputPath}`);
+  });
+
+  it("reports semantic cache fixture errors when key hash fields are missing", () => {
+    const inputPath = fixturePath("cache-input.missing-keyhash.v1.json");
+    const result = runAnalyzeCommand(["--mode", "cache", "--input", inputPath], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain("aurora analyze: cache mode failed");
+    expect(result.stderr).toContain("missing required string field (keyHash or hash)");
+  });
+
+  it("reports semantic realtime fixture errors when lag p95 fields are missing", () => {
+    const inputPath = fixturePath("realtime-input.missing-lag-p95.v1.json");
+    const result = runAnalyzeCommand(["--mode", "realtime", "--input", inputPath], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain("aurora analyze: realtime mode failed");
+    expect(result.stderr).toContain("missing required numeric field (lagP95Ms or p95)");
+  });
+
+  it("reports semantic query fixture errors for invalid cache status", () => {
+    const inputPath = fixturePath("query-input.invalid-cache-status.v1.json");
+    const result = runAnalyzeCommand(["--mode", "query", "--input", inputPath], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain("aurora analyze: query mode failed");
+    expect(result.stderr).toContain(
+      "missing required cache status field (cacheStatus/cache/status or hit)",
+    );
+  });
+
+  it("fails cache mode for unsupported schemaVersion", () => {
+    const inputPath = fixturePath("cache-input.unsupported-version.v2.json");
+    const result = runAnalyzeCommand(["--mode", "cache", "--input", inputPath], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain("aurora analyze: cache mode failed");
+    expect(result.stderr).toContain("unsupported schemaVersion 2 for cache input; expected 1");
+  });
+
+  it("fails realtime mode for unsupported schemaVersion", () => {
+    const inputPath = fixturePath("realtime-input.unsupported-version.v2.json");
+    const result = runAnalyzeCommand(["--mode", "realtime", "--input", inputPath], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain("aurora analyze: realtime mode failed");
+    expect(result.stderr).toContain("unsupported schemaVersion 2 for realtime input; expected 1");
+  });
+
+  it("fails query mode for unsupported schemaVersion", () => {
+    const inputPath = fixturePath("query-input.unsupported-version.v2.json");
+    const result = runAnalyzeCommand(["--mode", "query", "--input", inputPath], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain("aurora analyze: query mode failed");
+    expect(result.stderr).toContain("unsupported schemaVersion 2 for query input; expected 1");
+  });
+
+  it("fails guardrails mode for unsupported schemaVersion", () => {
+    const inputPath = fixturePath("guardrails-input.unsupported-version.v2.json");
+    const result = runAnalyzeCommand(["--mode", "guardrails", "--input", inputPath], {
+      cwd: projectRoot,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain("aurora analyze: guardrails mode failed");
+    expect(result.stderr).toContain("unsupported schemaVersion 2 for guardrails input; expected 1");
+  });
+
+  it("uses schemaVersion 1 for all analyze fixtures", () => {
+    const cacheFixture = JSON.parse(readFixture("cache-input.v1.json")) as { schemaVersion?: number };
+    const realtimeFixture = JSON.parse(readFixture("realtime-input.v1.json")) as { schemaVersion?: number };
+    const queryFixture = JSON.parse(readFixture("query-input.v1.json")) as { schemaVersion?: number };
+    const guardrailsFixture = JSON.parse(readFixture("guardrails-input.v1.json")) as { schemaVersion?: number };
+    const invalidCacheFixture = JSON.parse(readFixture("cache-input.missing-keyhash.v1.json")) as {
+      schemaVersion?: number;
+    };
+    const invalidRealtimeFixture = JSON.parse(
+      readFixture("realtime-input.missing-lag-p95.v1.json"),
+    ) as { schemaVersion?: number };
+    const invalidQueryFixture = JSON.parse(
+      readFixture("query-input.invalid-cache-status.v1.json"),
+    ) as { schemaVersion?: number };
+
+    expect(cacheFixture.schemaVersion).toBe(1);
+    expect(realtimeFixture.schemaVersion).toBe(1);
+    expect(queryFixture.schemaVersion).toBe(1);
+    expect(guardrailsFixture.schemaVersion).toBe(1);
+    expect(invalidCacheFixture.schemaVersion).toBe(1);
+    expect(invalidRealtimeFixture.schemaVersion).toBe(1);
+    expect(invalidQueryFixture.schemaVersion).toBe(1);
+  });
+
+  it("uses schemaVersion 2 for unsupported-version analyze fixtures", () => {
+    const cacheFixture = JSON.parse(readFixture("cache-input.unsupported-version.v2.json")) as {
+      schemaVersion?: number;
+    };
+    const realtimeFixture = JSON.parse(readFixture("realtime-input.unsupported-version.v2.json")) as {
+      schemaVersion?: number;
+    };
+    const queryFixture = JSON.parse(readFixture("query-input.unsupported-version.v2.json")) as {
+      schemaVersion?: number;
+    };
+    const guardrailsFixture = JSON.parse(
+      readFixture("guardrails-input.unsupported-version.v2.json"),
+    ) as {
+      schemaVersion?: number;
+    };
+
+    expect(cacheFixture.schemaVersion).toBe(2);
+    expect(realtimeFixture.schemaVersion).toBe(2);
+    expect(queryFixture.schemaVersion).toBe(2);
+    expect(guardrailsFixture.schemaVersion).toBe(2);
+  });
+});

package/test/build.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { runAuroraCli } from "../src";
+
+describe("aurora build", () => {
+  it("prints bootstrap output with node target defaults", () => {
+    const cwd = createTempWorkspace("aurora-build-default");
+    const result = runAuroraCli(["build"], { cwd });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("aurora build bootstrap");
+    expect(result.stdout).toContain("target: node");
+    expect(result.stdout).toContain(`output_path: ${cwd}/.aurora/build/node/server.mjs`);
+    expect(result.stdout).toContain("analyze: disabled");
+    expect(result.stdout).toContain("security_headers: enabled");
+    expect(result.stdout).toContain("raw_sql_tagged_template: enforced");
+    expect(result.stdout).toContain("dependency_audit_status: skipped-no-lockfile");
+  });
+
+  it("supports explicit edge/static target selection and analyze toggle", () => {
+    const cwd = createTempWorkspace("aurora-build-targets");
+
+    const edgeResult = runAuroraCli(
+      ["build", "--target", "edge", "--analyze", "--skip-audit"],
+      { cwd },
+    );
+    const staticResult = runAuroraCli(
+      ["build", "--target", "static", "--audit-severity", "critical"],
+      { cwd },
+    );
+
+    expect(edgeResult.exitCode).toBe(0);
+    expect(edgeResult.stdout).toContain("target: edge");
+    expect(edgeResult.stdout).toContain(`output_path: ${cwd}/.aurora/build/edge/worker.mjs`);
+    expect(edgeResult.stdout).toContain("analyze: enabled");
+    expect(edgeResult.stdout).toContain("dependency_audit_gate: disabled");
+    expect(edgeResult.stdout).toContain("dependency_audit_status: skipped-disabled");
+
+    expect(staticResult.exitCode).toBe(0);
+    expect(staticResult.stdout).toContain("target: static");
+    expect(staticResult.stdout).toContain(`output_path: ${cwd}/.aurora/build/static`);
+    expect(staticResult.stdout).toContain("dependency_audit_threshold: critical");
+  });
+
+  it("returns an error for invalid build/audit option values", () => {
+    const cwd = createTempWorkspace("aurora-build-errors");
+
+    const missingTarget = runAuroraCli(["build", "--target"], { cwd });
+    const invalidTarget = runAuroraCli(["build", "--target", "bun"], { cwd });
+    const missingSeverity = runAuroraCli(["build", "--audit-severity"], { cwd });
+    const invalidSeverity = runAuroraCli(
+      ["build", "--audit-severity", "none"],
+      { cwd },
+    );
+    const missingReportPath = runAuroraCli(["build", "--audit-report"], { cwd });
+
+    expect(missingTarget.exitCode).toBe(2);
+    expect(missingTarget.stderr).toContain(
+      "aurora build: --target requires one of 'node', 'edge', or 'static'",
+    );
+
+    expect(invalidTarget.exitCode).toBe(2);
+    expect(invalidTarget.stderr).toContain(
+      "aurora build: invalid target 'bun'. Expected 'node', 'edge', or 'static'",
+    );
+
+    expect(missingSeverity.exitCode).toBe(2);
+    expect(missingSeverity.stderr).toContain(
+      "aurora build: --audit-severity requires one of 'low', 'moderate', 'high', or 'critical'",
+    );
+
+    expect(invalidSeverity.exitCode).toBe(2);
+    expect(invalidSeverity.stderr).toContain(
+      "aurora build: invalid audit severity 'none'. Expected 'low', 'moderate', 'high', or 'critical'",
+    );
+
+    expect(missingReportPath.exitCode).toBe(2);
+    expect(missingReportPath.stderr).toContain(
+      "aurora build: --audit-report requires a path",
+    );
+  });
+
+  it("returns an error for unknown build options", () => {
+    const cwd = createTempWorkspace("aurora-build-unknown-option");
+    const result = runAuroraCli(["build", "--unknown"], { cwd });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("aurora build: unknown option '--unknown'");
+  });
+
+  it("fails when dependency audit report includes severity at/above threshold", () => {
+    const cwd = createTempWorkspace("aurora-build-audit-fail");
+    writeFileSync(join(cwd, "package-lock.json"), "{}", "utf8");
+    mkdirSync(join(cwd, ".aurora", "security"), { recursive: true });
+    writeFileSync(
+      join(cwd, ".aurora", "security", "dependency-audit.json"),
+      JSON.stringify(
+        {
+          vulnerabilities: [
+            {
+              package: "left-pad",
+              severity: "high",
+              advisory: "CVE-TEST-0001",
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+      "utf8",
+    );
+
+    const failed = runAuroraCli(["build"], { cwd });
+    const passed = runAuroraCli(["build", "--audit-severity", "critical"], { cwd });
+
+    expect(failed.exitCode).toBe(1);
+    expect(failed.stderr).toContain(
+      "aurora build: dependency audit failed for severity >= 'high'",
+    );
+
+    expect(passed.exitCode).toBe(0);
+    expect(passed.stdout).toContain("dependency_audit_status: passed");
+    expect(passed.stdout).toContain("dependency_lockfile:");
+    expect(passed.stdout).toContain("dependency_audit_report:");
+  });
+});
+
+function createTempWorkspace(prefix: string): string {
+  const unique = `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1_000_000)}`;
+  const cwd = join("/tmp", unique);
+  mkdirSync(cwd, { recursive: true });
+  return cwd;
+}

package/test/create-feature.test.ts

@@ -0,0 +1,145 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { runAuroraCli } from "../src";
+
+let tempCounter = 1;
+
+function uniqueTempPath(suffix: string): string {
+  tempCounter += 1;
+  return `/tmp/aurora-cli-create-feature-${suffix}-${Date.now()}-${tempCounter}`;
+}
+
+describe("aurora create-feature", () => {
+  it("scaffolds a feature folder from feature skeleton template", () => {
+    const cwd = uniqueTempPath("basic");
+    mkdirSync(cwd, { recursive: true });
+
+    const result = runAuroraCli(["create-feature", "audit-log"], { cwd });
+    const featureRoot = join(cwd, "src/features/audit-log");
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("aurora create-feature bootstrap");
+    expect(result.stdout).toContain("feature_slug: audit-log");
+    expect(result.stdout).toContain("feature_name: AuditLog");
+    expect(result.stdout).toContain("route_scaffold: enabled");
+    expect(result.stdout).toContain("route_kind: form");
+    expect(result.stdout).toContain("route_data_source: database");
+    expect(result.stdout).toContain("route_auth: public");
+    expect(result.stdout).toContain("route_realtime: disabled");
+
+    expect(existsSync(join(featureRoot, "ui/FeatureView.client.tsx"))).toBe(true);
+    expect(existsSync(join(featureRoot, "queries/listFeature.server.ts"))).toBe(true);
+    expect(existsSync(join(featureRoot, "actions/createFeature.action.server.ts"))).toBe(true);
+    expect(existsSync(join(featureRoot, "realtime/useFeatureRealtime.client.ts"))).toBe(true);
+    expect(existsSync(join(cwd, "src/routes/audit-log/page.tsx"))).toBe(true);
+    expect(existsSync(join(cwd, "src/routes/audit-log/audit-log.server.ts"))).toBe(true);
+    expect(existsSync(join(cwd, "src/routes/audit-log/audit-log.client.tsx"))).toBe(true);
+
+    const uiSource = readFileSync(join(featureRoot, "ui/FeatureView.client.tsx"), "utf8");
+    expect(uiSource).toContain("AuditLog");
+    expect(uiSource).toContain("audit-log");
+  });
+
+  it("normalizes non-kebab feature names to slug and pascal name", () => {
+    const cwd = uniqueTempPath("normalize");
+    mkdirSync(cwd, { recursive: true });
+
+    const result = runAuroraCli(["create-feature", "user_profile"], { cwd });
+    const featureRoot = join(cwd, "src/features/user-profile");
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("feature_slug: user-profile");
+    expect(result.stdout).toContain("feature_name: UserProfile");
+    expect(existsSync(featureRoot)).toBe(true);
+    expect(existsSync(join(cwd, "src/routes/user-profile/page.tsx"))).toBe(true);
+  });
+
+  it("supports disabling paired route scaffolding", () => {
+    const cwd = uniqueTempPath("no-route");
+    mkdirSync(cwd, { recursive: true });
+
+    const result = runAuroraCli(["create-feature", "notifications", "--no-route"], { cwd });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("route_scaffold: disabled");
+    expect(existsSync(join(cwd, "src/features/notifications"))).toBe(true);
+    expect(existsSync(join(cwd, "src/routes/notifications"))).toBe(false);
+  });
+
+  it("supports route scaffold option overrides", () => {
+    const cwd = uniqueTempPath("route-overrides");
+    mkdirSync(cwd, { recursive: true });
+
+    const result = runAuroraCli(
+      [
+        "create-feature",
+        "alerts",
+        "--kind",
+        "dashboard",
+        "--data",
+        "api",
+        "--auth",
+        "user",
+        "--realtime",
+      ],
+      { cwd },
+    );
+
+    const routeServer = join(cwd, "src/routes/alerts/alerts.server.ts");
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("route_kind: dashboard");
+    expect(result.stdout).toContain("route_data_source: api");
+    expect(result.stdout).toContain("route_auth: user");
+    expect(result.stdout).toContain("route_realtime: enabled");
+    expect(readFileSync(routeServer, "utf8")).toContain("AlertsRealtimeChannel");
+  });
+
+  it("returns an error when feature name is missing", () => {
+    const cwd = uniqueTempPath("missing");
+    mkdirSync(cwd, { recursive: true });
+
+    const result = runAuroraCli(["create-feature"], { cwd });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("aurora create-feature: feature name is required");
+  });
+
+  it("returns an error for unknown options", () => {
+    const cwd = uniqueTempPath("unknown-option");
+    mkdirSync(cwd, { recursive: true });
+
+    const result = runAuroraCli(["create-feature", "billing", "--dry-run"], { cwd });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("aurora create-feature: unknown option '--dry-run'");
+  });
+
+  it("returns an error when feature directory already exists and is not empty", () => {
+    const cwd = uniqueTempPath("exists");
+    const featureRoot = join(cwd, "src/features/chat");
+    mkdirSync(featureRoot, { recursive: true });
+    writeFileSync(join(featureRoot, "seed.txt"), "seed\n", "utf8");
+
+    const result = runAuroraCli(["create-feature", "chat"], { cwd });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("target directory already exists and is not empty");
+  });
+
+  it("returns an error when paired route directory already exists and is not empty", () => {
+    const cwd = uniqueTempPath("route-exists");
+    const routeRoot = join(cwd, "src/routes/billing");
+    mkdirSync(routeRoot, { recursive: true });
+    writeFileSync(join(routeRoot, "seed.txt"), "seed\n", "utf8");
+
+    const result = runAuroraCli(["create-feature", "billing"], { cwd });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("target directory already exists and is not empty");
+    expect(result.stderr).toContain(routeRoot);
+  });
+});