@sansavision/aurora 0.1.0-alpha.20260212.4

package/test/inspect-cache.test.ts

@@ -0,0 +1,112 @@
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { runAuroraCli } from "../src";
+
+const projectRoot = join(import.meta.dir, "..");
+
+function fixturePath(name: string): string {
+  return join("test/fixtures/cache-inspector", name);
+}
+
+describe("aurora inspect-cache", () => {
+  it("renders a text report for cache snapshot input", () => {
+    const result = runAuroraCli(
+      ["inspect-cache", "--input", fixturePath("snapshot.v1.json")],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("aurora cache inspector report");
+    expect(result.stdout).toContain("entries_total: 3");
+    expect(result.stdout).toContain("entries_filtered: 3");
+    expect(result.stdout).toContain("stale_entries: 1");
+    expect(result.stdout).toContain("largest_entries:");
+  });
+
+  it("supports json output with tag filtering and row limits", () => {
+    const result = runAuroraCli(
+      [
+        "inspect-cache",
+        "--input",
+        fixturePath("cache-input.v1.json"),
+        "--tag",
+        "users",
+        "--limit",
+        "1",
+        "--format",
+        "json",
+      ],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      entries?: number;
+      filteredEntries?: number;
+      staleEntries?: number;
+      topTags?: Array<{ tag?: string; entries?: number }>;
+      largestEntries?: Array<{ key?: string; sizeBytes?: number }>;
+    };
+
+    expect(parsed.mode).toBe("cache-inspector");
+    expect(parsed.entries).toBe(3);
+    expect(parsed.filteredEntries).toBe(2);
+    expect(parsed.staleEntries).toBe(1);
+    expect(parsed.topTags?.[0]?.tag).toBe("users");
+    expect(parsed.topTags?.[0]?.entries).toBe(2);
+    expect(parsed.largestEntries?.length).toBe(1);
+    expect(parsed.largestEntries?.[0]?.key).toBe("users:u2");
+    expect(parsed.largestEntries?.[0]?.sizeBytes).toBe(256);
+  });
+
+  it("requires --input", () => {
+    const result = runAuroraCli(["inspect-cache"], { cwd: projectRoot });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("aurora inspect-cache: --input is required");
+  });
+
+  it("rejects invalid limit values and unknown options", () => {
+    const invalidLimit = runAuroraCli(
+      ["inspect-cache", "--input", fixturePath("snapshot.v1.json"), "--limit", "0"],
+      { cwd: projectRoot },
+    );
+    const unknown = runAuroraCli(
+      ["inspect-cache", "--input", fixturePath("snapshot.v1.json"), "--unknown"],
+      { cwd: projectRoot },
+    );
+
+    expect(invalidLimit.exitCode).toBe(2);
+    expect(invalidLimit.stderr).toContain(
+      "aurora inspect-cache: --limit must be an integer between 1 and 500",
+    );
+    expect(unknown.exitCode).toBe(2);
+    expect(unknown.stderr).toContain("aurora inspect-cache: unknown option '--unknown'");
+  });
+
+  it("fails for invalid json or unsupported input versions", () => {
+    const invalidJsonPath = fixturePath("invalid.json");
+    const unsupportedVersionPath = fixturePath("unsupported-version.v2.json");
+
+    const invalidJson = runAuroraCli(
+      ["inspect-cache", "--input", invalidJsonPath],
+      { cwd: projectRoot },
+    );
+    const unsupportedVersion = runAuroraCli(
+      ["inspect-cache", "--input", unsupportedVersionPath],
+      { cwd: projectRoot },
+    );
+
+    expect(invalidJson.exitCode).toBe(1);
+    expect(invalidJson.stderr).toContain(
+      `aurora inspect-cache: invalid json input at ${invalidJsonPath}`,
+    );
+    expect(unsupportedVersion.exitCode).toBe(1);
+    expect(unsupportedVersion.stderr).toContain(
+      "aurora inspect-cache: unsupported cache snapshot version 2; expected 1",
+    );
+  });
+});

package/test/lsp-inline-hints.test.ts

@@ -0,0 +1,65 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import {
+  createInlineHintsFromExplainReport,
+  type ExplainModuleReportV1,
+} from "../src";
+
+function loadExplainFixture(name: string): ExplainModuleReportV1 {
+  const raw = readFileSync(join(import.meta.dir, "fixtures/explain", name), "utf8");
+  return JSON.parse(raw) as ExplainModuleReportV1;
+}
+
+describe("createInlineHintsFromExplainReport", () => {
+  it("emits key/tag/invalidation/auth/runtime inline hints with stable ordering", () => {
+    const report = loadExplainFixture("module-report.v1.json");
+    const source = [
+      'export const runtime = "edge";',
+      'export const auth = "user";',
+      "",
+      "export const listMessages = defineQuery({});",
+      "export const addMessage = defineAction({});",
+    ].join("\n");
+
+    const hints = createInlineHintsFromExplainReport(source, report);
+
+    expect(hints.length >= 7).toBe(true);
+
+    const keyHint = hints.find((hint) => hint.kind === "key" && hint.symbol === "listMessages");
+    const tagsHint = hints.find((hint) => hint.kind === "tags" && hint.symbol === "listMessages");
+    const invalidationHint = hints.find(
+      (hint) => hint.kind === "invalidation" && hint.symbol === "addMessage",
+    );
+    const actionAuthHint = hints.find((hint) => hint.kind === "auth" && hint.symbol === "addMessage");
+    const runtimeHint = hints.find((hint) => hint.kind === "runtime" && hint.symbol === "module");
+    const moduleAuthHint = hints.find((hint) => hint.kind === "auth" && hint.symbol === "module");
+
+    expect(keyHint?.label).toContain("key:");
+    expect(tagsHint?.label).toContain("tags:");
+    expect(invalidationHint?.label).toContain("invalidates:");
+    expect(actionAuthHint?.label).toContain("auth: public");
+    expect(runtimeHint?.label).toBe("runtime: edge");
+    expect(moduleAuthHint?.label).toBe("auth: user");
+
+    expect(runtimeHint?.position.line).toBe(0);
+    expect(moduleAuthHint?.position.line).toBe(1);
+
+    const lines = hints.map((hint) => hint.position.line);
+    const sorted = [...lines].sort((left, right) => left - right);
+    expect(lines).toEqual(sorted);
+  });
+
+  it("does not emit query/action hints when symbols are missing from source", () => {
+    const report = loadExplainFixture("module-report.v1.json");
+    const source = 'export const runtime = "node";';
+
+    const hints = createInlineHintsFromExplainReport(source, report);
+
+    expect(hints.some((hint) => hint.symbol === "listMessages")).toBe(false);
+    expect(hints.some((hint) => hint.symbol === "addMessage")).toBe(false);
+    expect(hints.some((hint) => hint.kind === "runtime")).toBe(true);
+  });
+});

package/test/query-profiler.test.ts

@@ -0,0 +1,123 @@
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { runAuroraCli } from "../src";
+
+const projectRoot = join(import.meta.dir, "..");
+
+function fixturePath(name: string): string {
+  return join("test/fixtures/query-profiler", name);
+}
+
+describe("aurora profile-query", () => {
+  it("reports healthy query metrics with default thresholds", () => {
+    const result = runAuroraCli(
+      ["profile-query", "--input", fixturePath("healthy.v1.json")],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("aurora query profiler report");
+    expect(result.stdout).toContain("status: ok");
+    expect(result.stdout).toContain("cache_hit_ratio: 0.6667");
+    expect(result.stdout).toContain("p95_ms: 35.00");
+  });
+
+  it("returns warn status and non-zero exit when thresholds are exceeded", () => {
+    const result = runAuroraCli(
+      ["profile-query", "--input", fixturePath("warning.v1.json")],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stdout).toContain("status: warn");
+    expect(result.stdout).toContain("[QUERY_P95_EXCEEDED]");
+    expect(result.stdout).toContain("[CACHE_HIT_RATIO_BELOW_MIN]");
+  });
+
+  it("supports json output and custom thresholds", () => {
+    const result = runAuroraCli(
+      [
+        "profile-query",
+        "--input",
+        fixturePath("healthy.v1.json"),
+        "--format",
+        "json",
+        "--max-p95-ms",
+        "40",
+        "--min-cache-hit-ratio",
+        "0.5",
+        "--limit",
+        "1",
+      ],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      status?: string;
+      p95Ms?: number;
+      cacheHitRatio?: number;
+      slowQueries?: Array<{ queryName?: string }>;
+      thresholds?: {
+        maxP95Ms?: number;
+        minCacheHitRatio?: number;
+      };
+    };
+
+    expect(parsed.mode).toBe("query-profiler");
+    expect(parsed.status).toBe("ok");
+    expect(parsed.p95Ms).toBe(35);
+    expect((parsed.cacheHitRatio ?? 0).toFixed(4)).toBe("0.6667");
+    expect(parsed.thresholds?.maxP95Ms).toBe(40);
+    expect(parsed.thresholds?.minCacheHitRatio).toBe(0.5);
+    expect(parsed.slowQueries?.length).toBe(1);
+    expect(parsed.slowQueries?.[0]?.queryName).toBe("teams.list");
+  });
+
+  it("rejects missing input, invalid limits, and unknown options", () => {
+    const missingInput = runAuroraCli(["profile-query"], { cwd: projectRoot });
+    const invalidLimit = runAuroraCli(
+      ["profile-query", "--input", fixturePath("healthy.v1.json"), "--limit", "0"],
+      { cwd: projectRoot },
+    );
+    const unknown = runAuroraCli(
+      ["profile-query", "--input", fixturePath("healthy.v1.json"), "--unknown"],
+      { cwd: projectRoot },
+    );
+
+    expect(missingInput.exitCode).toBe(2);
+    expect(missingInput.stderr).toContain("aurora profile-query: --input is required");
+    expect(invalidLimit.exitCode).toBe(2);
+    expect(invalidLimit.stderr).toContain(
+      "aurora profile-query: --limit must be an integer between 1 and 200",
+    );
+    expect(unknown.exitCode).toBe(2);
+    expect(unknown.stderr).toContain("aurora profile-query: unknown option '--unknown'");
+  });
+
+  it("fails for invalid json and unsupported schema versions", () => {
+    const invalidJsonPath = fixturePath("invalid.json");
+    const unsupportedPath = fixturePath("unsupported-version.v2.json");
+
+    const invalidJson = runAuroraCli(
+      ["profile-query", "--input", invalidJsonPath],
+      { cwd: projectRoot },
+    );
+    const unsupported = runAuroraCli(
+      ["profile-query", "--input", unsupportedPath],
+      { cwd: projectRoot },
+    );
+
+    expect(invalidJson.exitCode).toBe(1);
+    expect(invalidJson.stderr).toContain(
+      `aurora profile-query: invalid json input at ${invalidJsonPath}`,
+    );
+    expect(unsupported.exitCode).toBe(1);
+    expect(unsupported.stderr).toContain(
+      "aurora profile-query: unsupported schemaVersion 2 for query input; expected 1",
+    );
+  });
+});

package/test/realtime-monitor.test.ts

@@ -0,0 +1,115 @@
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { runAuroraCli } from "../src";
+
+const projectRoot = join(import.meta.dir, "..");
+
+function fixturePath(name: string): string {
+  return join("test/fixtures/realtime-monitor", name);
+}
+
+describe("aurora monitor-realtime", () => {
+  it("reports healthy realtime metrics with default thresholds", () => {
+    const result = runAuroraCli(
+      ["monitor-realtime", "--input", fixturePath("healthy.v1.json")],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("aurora realtime monitor report");
+    expect(result.stdout).toContain("status: ok");
+    expect(result.stdout).toContain("drop_ratio: 0.0100");
+    expect(result.stdout).toContain("lag_p95_ms: 140");
+  });
+
+  it("returns warn status and non-zero exit when thresholds are exceeded", () => {
+    const result = runAuroraCli(
+      ["monitor-realtime", "--input", fixturePath("warning.v1.json")],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stdout).toContain("status: warn");
+    expect(result.stdout).toContain("[DROP_RATIO_EXCEEDED]");
+    expect(result.stdout).toContain("[LAG_P95_EXCEEDED]");
+  });
+
+  it("supports json output and custom thresholds", () => {
+    const result = runAuroraCli(
+      [
+        "monitor-realtime",
+        "--input",
+        fixturePath("healthy.v1.json"),
+        "--format",
+        "json",
+        "--max-drop-ratio",
+        "0.02",
+        "--max-lag-p95-ms",
+        "180",
+        "--min-delivered-rps",
+        "10",
+      ],
+      { cwd: projectRoot },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      status?: string;
+      dropRatio?: number;
+      deliveredRps?: number;
+      thresholds?: {
+        minDeliveredRps?: number;
+      };
+      issues?: unknown[];
+    };
+
+    expect(parsed.mode).toBe("realtime-monitor");
+    expect(parsed.status).toBe("ok");
+    expect(parsed.dropRatio).toBe(0.01);
+    expect(parsed.deliveredRps).toBe(19.8);
+    expect(parsed.thresholds?.minDeliveredRps).toBe(10);
+    expect(parsed.issues?.length).toBe(0);
+  });
+
+  it("rejects missing input and unknown options", () => {
+    const missingInput = runAuroraCli(["monitor-realtime"], {
+      cwd: projectRoot,
+    });
+    const unknown = runAuroraCli(
+      ["monitor-realtime", "--input", fixturePath("healthy.v1.json"), "--unknown"],
+      { cwd: projectRoot },
+    );
+
+    expect(missingInput.exitCode).toBe(2);
+    expect(missingInput.stderr).toContain(
+      "aurora monitor-realtime: --input is required",
+    );
+    expect(unknown.exitCode).toBe(2);
+    expect(unknown.stderr).toContain(
+      "aurora monitor-realtime: unknown option '--unknown'",
+    );
+  });
+
+  it("fails for invalid json and unsupported schema versions", () => {
+    const invalidJson = runAuroraCli(
+      ["monitor-realtime", "--input", fixturePath("invalid.json")],
+      { cwd: projectRoot },
+    );
+    const unsupported = runAuroraCli(
+      ["monitor-realtime", "--input", fixturePath("unsupported-version.v2.json")],
+      { cwd: projectRoot },
+    );
+
+    expect(invalidJson.exitCode).toBe(1);
+    expect(invalidJson.stderr).toContain(
+      `aurora monitor-realtime: invalid json input at ${fixturePath("invalid.json")}`,
+    );
+    expect(unsupported.exitCode).toBe(1);
+    expect(unsupported.stderr).toContain(
+      "aurora monitor-realtime: unsupported schemaVersion 2 for realtime input; expected 1",
+    );
+  });
+});

package/test/registry.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "bun:test";
+
+import { commandRegistry, findCommand } from "../src";
+
+describe("command registry", () => {
+  it("contains the baseline command set for bootstrap", () => {
+    const names = new Set(commandRegistry.map((command) => command.name));
+    const required = [
+      "create",
+      "init",
+      "dev",
+      "devtools",
+      "build",
+      "start",
+      "analyze",
+      "ai",
+      "doctor",
+      "explain",
+      "inspect-cache",
+      "monitor-realtime",
+      "profile-query",
+      "test",
+      "create-feature",
+      "create-route",
+    ];
+
+    for (const name of required) {
+      expect(names.has(name)).toBe(true);
+    }
+  });
+
+  it("registers unique command names", () => {
+    const names = commandRegistry.map((command) => command.name);
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  it("findCommand resolves registered commands and rejects unknown commands", () => {
+    expect(findCommand("dev")?.name).toBe("dev");
+    expect(findCommand("missing")).toBe(undefined);
+  });
+});

package/test/start.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "bun:test";
+
+import { runAuroraCli } from "../src";
+
+describe("aurora start", () => {
+  const cwd = "/tmp/aurora-start";
+
+  it("prints production runtime bootstrap output", () => {
+    const result = runAuroraCli(["start"], { cwd });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("aurora start bootstrap");
+    expect(result.stdout).toContain("runtime_bundle: /tmp/aurora-start/.aurora/build/node/server.mjs");
+    expect(result.stdout).toContain("url: http://localhost:3000");
+  });
+
+  it("returns an error for unknown options", () => {
+    const result = runAuroraCli(["start", "--port", "4310"], { cwd });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("aurora start: unknown option '--port'");
+  });
+});

package/test/test-command.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync } from "node:fs";
+
+import { runAuroraCli } from "../src";
+
+let tempCounter = 0;
+
+function uniqueTempPath(suffix: string): string {
+  tempCounter += 1;
+  return `/tmp/aurora-cli-test-command-${suffix}-${Date.now()}-${tempCounter}`;
+}
+
+describe("aurora test", () => {
+  it("runs e2e matrix wrapper for all default template profiles", () => {
+    const cwd = uniqueTempPath("all");
+    mkdirSync(cwd, { recursive: true });
+
+    const result = runAuroraCli(["test"], { cwd });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("aurora test integration runner");
+    expect(result.stdout).toContain("projects_total: 4");
+    expect(result.stdout).toContain("projects_failed: 0");
+    expect(result.stdout).toContain("basic (basic): PASS");
+    expect(result.stdout).toContain("dashboard (dashboard): PASS");
+  });
+
+  it("supports template filter and json report output", () => {
+    const cwd = uniqueTempPath("json");
+    mkdirSync(cwd, { recursive: true });
+
+    const result = runAuroraCli(["test", "--template", "blog", "--format", "json"], {
+      cwd,
+    });
+
+    expect(result.exitCode).toBe(0);
+    const report = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      templateFilter?: string;
+      projectsTotal?: number;
+      projectsFailed?: number;
+      results?: Array<{ id: string; passed: boolean }>;
+    };
+
+    expect(report.mode).toBe("test");
+    expect(report.templateFilter).toBe("blog");
+    expect(report.projectsTotal).toBe(1);
+    expect(report.projectsFailed).toBe(0);
+    expect(report.results?.[0]?.id).toBe("blog");
+    expect(report.results?.[0]?.passed).toBe(true);
+  });
+
+  it("returns parse errors for invalid template and unknown options", () => {
+    const cwd = uniqueTempPath("invalid");
+    mkdirSync(cwd, { recursive: true });
+
+    const invalidTemplate = runAuroraCli(["test", "--template", "mobile"], { cwd });
+    expect(invalidTemplate.exitCode).toBe(2);
+    expect(invalidTemplate.stderr).toContain("invalid template 'mobile'");
+
+    const unknownOption = runAuroraCli(["test", "--suite", "matrix"], { cwd });
+    expect(unknownOption.exitCode).toBe(2);
+    expect(unknownOption.stderr).toContain("unknown option '--suite'");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "noImplicitThis": true,
+    "declaration": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.d.ts",
+    "test/**/*.ts",
+    "test/**/*.d.ts"
+  ]
+}