@sansavision/aurora 0.1.0-alpha.20260212.4

package/test/fixtures/devtools/unsupported-version.v2.json

@@ -0,0 +1,8 @@
+{
+  "schemaVersion": 2,
+  "explain": {},
+  "waterfall": {},
+  "performance": {},
+  "realtime": {},
+  "auth": {}
+}

package/test/fixtures/devtools/warn.v1.json

@@ -0,0 +1,114 @@
+{
+  "schemaVersion": 1,
+  "explain": {
+    "module": "routes/dashboard/dashboard.server.ts",
+    "queries": [
+      {
+        "name": "listDashboardStats",
+        "realtime": "subscribed via tags"
+      },
+      {
+        "name": "listAudits",
+        "auth": "admin"
+      }
+    ],
+    "actions": [
+      {
+        "name": "refreshAll"
+      }
+    ],
+    "warnings": [
+      "action refreshAll has no explicit errors() channel"
+    ]
+  },
+  "waterfall": {
+    "requestId": "req-warn",
+    "operations": [
+      {
+        "name": "route.match",
+        "kind": "routing",
+        "startMs": 0,
+        "durationMs": 4,
+        "blocking": false
+      },
+      {
+        "name": "listDashboardStats",
+        "kind": "query",
+        "startMs": 4,
+        "durationMs": 260,
+        "blocking": true
+      },
+      {
+        "name": "listAudits",
+        "kind": "query",
+        "startMs": 270,
+        "durationMs": 180,
+        "blocking": true
+      },
+      {
+        "name": "render",
+        "kind": "render",
+        "startMs": 460,
+        "durationMs": 92,
+        "blocking": true
+      }
+    ],
+    "phases": [
+      {
+        "name": "routing",
+        "durationMs": 4
+      },
+      {
+        "name": "data",
+        "durationMs": 440
+      },
+      {
+        "name": "render",
+        "durationMs": 92
+      }
+    ]
+  },
+  "performance": {
+    "routes": [
+      {
+        "route": "/dashboard",
+        "jsBytes": 210000,
+        "payloadBytes": 58000,
+        "lcpMs": 980
+      },
+      {
+        "route": "/dashboard/audits",
+        "jsBytes": 170000,
+        "payloadBytes": 31000,
+        "lcpMs": 860
+      }
+    ]
+  },
+  "realtime": {
+    "connectionState": "reconnecting",
+    "eventsPerSecond": 4.2,
+    "lagP95Ms": 420,
+    "droppedRatio": 0.16,
+    "subscriptions": [
+      {
+        "tag": "dashboard:stats",
+        "channel": "dashboard.ws",
+        "state": "active",
+        "authScope": "admin"
+      },
+      {
+        "tag": "dashboard:alerts",
+        "channel": "dashboard.ws",
+        "state": "active"
+      }
+    ]
+  },
+  "auth": {
+    "sessionStatus": "expired",
+    "routeAuth": "admin",
+    "permissions": [
+      "dashboard:read"
+    ],
+    "tokenExpiresInSec": 120
+  }
+}

package/test/fixtures/doctor/clean/src/page.tsx

@@ -0,0 +1,3 @@
+export default function Page() {
+  return null;
+}

package/test/fixtures/doctor/findings/src/accessibility.client.tsx

@@ -0,0 +1,7 @@
+export function AvatarCard(): string {
+  return '<div onClick={handleOpen}><img src="/avatar.png" /></div>';
+}
+
+function handleOpen(): void {
+  // noop
+}

package/test/fixtures/doctor/findings/src/migration.config.ts

@@ -0,0 +1,3 @@
+export const config = {
+  routes: ["/", "/users"],
+};

package/test/fixtures/doctor/findings/src/page.client.tsx

@@ -0,0 +1,5 @@
+import { listUsers } from "./users.server";
+
+export function ClientPage() {
+  return <div>{typeof listUsers}</div>;
+}

package/test/fixtures/doctor/findings/src/perf.server.ts

@@ -0,0 +1,15 @@
+export async function listEverything(repo: { findMany: () => Promise<unknown[]> }): Promise<unknown[]> {
+  return repo.findMany();
+}
+
+export async function hydrateUsers(
+  ids: readonly string[],
+  api: { fetchUser: (id: string) => Promise<unknown> },
+): Promise<unknown[]> {
+  const users: unknown[] = [];
+  for (const id of ids) {
+    users.push(await api.fetchUser(id));
+  }
+
+  return users;
+}

package/test/fixtures/doctor/findings/src/routes.js

@@ -0,0 +1,3 @@
+const legacyRoute = route("/legacy", {});
+
+export { legacyRoute };

package/test/fixtures/doctor/findings/src/security.server.ts

@@ -0,0 +1,7 @@
+export function runUnsafe(payload: string): unknown {
+  return eval(payload);
+}
+
+export async function listUsers(db: { query: (sql: string) => Promise<unknown[]> }): Promise<unknown[]> {
+  return db.query("select * from users");
+}

package/test/fixtures/doctor/findings/src/users.server.ts

@@ -0,0 +1,3 @@
+export function listUsers(): string[] {
+  return [];
+}

package/test/fixtures/doctor/governance/src/features/analytics/OWNERS.ts

@@ -0,0 +1,2 @@
+export const owners = ["analytics-team"];
+export const reviewers = ["@platform-reviewers"];

package/test/fixtures/doctor/governance/src/features/analytics/page.tsx

@@ -0,0 +1,3 @@
+export function AnalyticsPage(): null {
+  return null;
+}

package/test/fixtures/doctor/governance/src/features/billing/page.tsx

@@ -0,0 +1,3 @@
+export function BillingPage(): null {
+  return null;
+}

package/test/fixtures/explain/invalid.json

@@ -0,0 +1 @@
+{ "schemaVersion": 1, "module": "routes/example.server.ts", "queries": [

package/test/fixtures/explain/module-report.unsupported-version.v2.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 2,
+  "module": "routes/guestbook/guestbook.server.ts",
+  "queries": [],
+  "actions": []
+}

package/test/fixtures/explain/module-report.v1.json

@@ -0,0 +1,72 @@
+{
+  "schemaVersion": 1,
+  "module": "routes/guestbook/guestbook.server.ts",
+  "queries": [
+    {
+      "name": "listMessages",
+      "key": {
+        "value": [
+          "routes/guestbook/guestbook.server",
+          "listMessages",
+          "hash(args)"
+        ],
+        "source": "inferred"
+      },
+      "tags": {
+        "value": ["guestbook:messages"],
+        "source": "explicit"
+      },
+      "cache": {
+        "value": {
+          "staleTime": "10s",
+          "gcTime": "10m"
+        },
+        "source": "explicit"
+      },
+      "realtime": {
+        "value": "subscribed via tags",
+        "source": "inferred"
+      },
+      "auth": {
+        "value": "user",
+        "source": "inherited"
+      },
+      "mask": {
+        "value": "none",
+        "source": "none"
+      },
+      "estimatedPayloadBytes": 2458
+    }
+  ],
+  "actions": [
+    {
+      "name": "addMessage",
+      "invalidates": {
+        "value": ["guestbook:messages"],
+        "source": "explicit"
+      },
+      "publishes": {
+        "value": ["guestbook.messageAdded"],
+        "source": "explicit"
+      },
+      "auth": {
+        "value": "public",
+        "source": "explicit"
+      },
+      "rateLimit": {
+        "value": "20/10s",
+        "source": "explicit"
+      },
+      "input": {
+        "value": "{ text: string (1-200 chars) }",
+        "source": "explicit"
+      },
+      "errors": {
+        "value": [],
+        "source": "none"
+      },
+      "suggestions": ["consider adding .errors() for client-side error handling"]
+    }
+  ],
+  "warnings": []
+}

package/test/fixtures/query-profiler/healthy.v1.json

@@ -0,0 +1,11 @@
+{
+  "schemaVersion": 1,
+  "samples": [
+    { "name": "users.byId", "key": "users:u1", "ms": 10, "cache": "hit" },
+    { "name": "users.byId", "key": "users:u2", "ms": 12, "cache": "hit" },
+    { "name": "teams.list", "key": "teams:list", "ms": 35, "cache": "miss" },
+    { "name": "teams.list", "key": "teams:list", "ms": 30, "cache": "stale" },
+    { "name": "projects.list", "key": "projects:list", "ms": 25, "cache": "hit" },
+    { "name": "projects.list", "key": "projects:list", "ms": 18, "cache": "hit" }
+  ]
+}

package/test/fixtures/query-profiler/invalid.json

@@ -0,0 +1 @@
+{ "schemaVersion": 1, "samples": [ { "name": "users.byId" } 

package/test/fixtures/query-profiler/unsupported-version.v2.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 2,
+  "samples": [
+    { "name": "users.byId", "key": "users:u1", "ms": 20, "cache": "hit" }
+  ]
+}

package/test/fixtures/query-profiler/warning.v1.json

@@ -0,0 +1,10 @@
+{
+  "schemaVersion": 1,
+  "samples": [
+    { "name": "users.byId", "key": "users:u1", "ms": 120, "cache": "miss" },
+    { "name": "users.byId", "key": "users:u2", "ms": 150, "cache": "miss" },
+    { "name": "teams.list", "key": "teams:list", "ms": 95, "cache": "hit" },
+    { "name": "teams.list", "key": "teams:list", "ms": 180, "cache": "stale" },
+    { "name": "projects.list", "key": "projects:list", "ms": 130, "cache": "miss" }
+  ]
+}

package/test/fixtures/realtime-monitor/healthy.v1.json

@@ -0,0 +1,8 @@
+{
+  "schemaVersion": 1,
+  "rx": 1200,
+  "tx": 1188,
+  "dropped": 12,
+  "lagP95Ms": 140,
+  "windowSeconds": 60
+}

package/test/fixtures/realtime-monitor/invalid.json

@@ -0,0 +1 @@
+{ "schemaVersion": 1, "rx": 1200, "tx": 1188

package/test/fixtures/realtime-monitor/unsupported-version.v2.json

@@ -0,0 +1,8 @@
+{
+  "schemaVersion": 2,
+  "rx": 1200,
+  "tx": 1188,
+  "dropped": 12,
+  "lagP95Ms": 140,
+  "windowSeconds": 60
+}

package/test/fixtures/realtime-monitor/warning.v1.json

@@ -0,0 +1,8 @@
+{
+  "schemaVersion": 1,
+  "rx": 100,
+  "tx": 70,
+  "dropped": 30,
+  "lagP95Ms": 420,
+  "windowSeconds": 10
+}

package/test/help-parity.test.ts

@@ -0,0 +1,104 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { commandRegistry, renderCommandHelp, renderGlobalHelp } from "../src";
+
+function parseDocumentedGlobalCommands(markdown: string): string[] {
+  const block = markdown.match(/## Global Commands\s+```([\s\S]*?)```/);
+  if (!block) {
+    return [];
+  }
+
+  return block[1]
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("aurora "))
+    .map((line) => {
+      const tokens = line.split(/\s+/);
+      return tokens[1] ?? "";
+    })
+    .filter((command) => command.length > 0);
+}
+
+function parseDocumentedSectionOptions(markdown: string, section: string): string[] {
+  const sectionHeading = `## ${section}`;
+  const sectionIndex = markdown.indexOf(sectionHeading);
+  if (sectionIndex < 0) {
+    return [];
+  }
+
+  const fenceStart = markdown.indexOf("```", sectionIndex);
+  if (fenceStart < 0) {
+    return [];
+  }
+
+  const fenceEnd = markdown.indexOf("```", fenceStart + 3);
+  if (fenceEnd < 0) {
+    return [];
+  }
+
+  return markdown
+    .slice(fenceStart + 3, fenceEnd)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("--"))
+    .map((line) => line.split(/\s{2,}/)[0] ?? line)
+    .filter((line) => line.length > 0);
+}
+
+describe("CLI/docs parity", () => {
+  const markdown = readFileSync(
+    join(import.meta.dir, "../../plan/aurora_cli_help.md"),
+    "utf8",
+  );
+
+  it("supports every command documented in global command help", () => {
+    const documentedCommands = parseDocumentedGlobalCommands(markdown);
+    const implemented = new Set(commandRegistry.map((command) => command.name));
+
+    for (const documented of documentedCommands) {
+      expect(implemented.has(documented)).toBe(true);
+    }
+  });
+
+  it("renders every documented command in global help output", () => {
+    const documentedCommands = parseDocumentedGlobalCommands(markdown);
+    const output = renderGlobalHelp();
+
+    for (const documented of documentedCommands) {
+      expect(output).toContain(documented);
+    }
+  });
+
+  it("includes documented scaffold/core command options in command help", () => {
+    const cases = [
+      { section: "create", commandName: "create" },
+      { section: "init", commandName: "init" },
+      { section: "create-route", commandName: "create-route" },
+      { section: "create-feature", commandName: "create-feature" },
+      { section: "dev", commandName: "dev" },
+      { section: "devtools", commandName: "devtools" },
+      { section: "build", commandName: "build" },
+      { section: "analyze", commandName: "analyze" },
+      { section: "ai", commandName: "ai" },
+      { section: "explain", commandName: "explain" },
+    ];
+
+    for (const entry of cases) {
+      const command = commandRegistry.find((item) => item.name === entry.commandName);
+      expect(command).toBeDefined();
+      if (!command) {
+        continue;
+      }
+
+      const help = renderCommandHelp(command);
+      const documentedFlags = parseDocumentedSectionOptions(markdown, entry.section);
+
+      for (const flag of documentedFlags) {
+        expect(help).toContain(flag);
+      }
+    }
+  });
+});

package/test/init.test.ts

@@ -0,0 +1,164 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { runAuroraCli } from "../src";
+
+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;
+}
+
+describe("aurora init", () => {
+  it("scaffolds a next.js migration suite with incremental mount and react interop bridge", () => {
+    const cwd = createTempWorkspace("aurora-init-next");
+    mkdirSync(join(cwd, "pages", "blog"), { recursive: true });
+    mkdirSync(join(cwd, "app", "dashboard"), { recursive: true });
+    writeFileSync(
+      join(cwd, "pages", "index.tsx"),
+      "export const getServerSideProps = async () => ({ props: {} });\n",
+      "utf8",
+    );
+    writeFileSync(
+      join(cwd, "pages", "blog", "[slug].tsx"),
+      "export default function BlogPost() { return null; }\n",
+      "utf8",
+    );
+    writeFileSync(
+      join(cwd, "app", "dashboard", "page.tsx"),
+      "export default function Dashboard() { return null; }\n",
+      "utf8",
+    );
+
+    const result = runAuroraCli(
+      ["init", "--from", "next", "--out-dir", "migration", "--format", "json"],
+      { cwd },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      mode?: string;
+      framework?: string;
+      migrationMode?: string;
+      bridge?: string;
+      detectedRoutes?: number;
+      loaderCandidates?: number;
+      generatedFiles?: string[];
+    };
+
+    expect(parsed.mode).toBe("init-migration");
+    expect(parsed.framework).toBe("next");
+    expect(parsed.migrationMode).toBe("incremental");
+    expect(parsed.bridge).toBe("react");
+    expect(parsed.detectedRoutes).toBe(3);
+    expect((parsed.loaderCandidates ?? 0) >= 1).toBe(true);
+    expect(parsed.generatedFiles?.includes("incremental/mount.server.ts")).toBe(true);
+    expect(parsed.generatedFiles?.includes("interop/react-bridge.tsx")).toBe(true);
+    expect(existsSync(join(cwd, "migration", "migration-checklist.md"))).toBe(true);
+    expect(existsSync(join(cwd, "migration", "incremental", "mount.server.ts"))).toBe(true);
+    expect(existsSync(join(cwd, "migration", "interop", "react-bridge.tsx"))).toBe(true);
+  });
+
+  it("supports side-by-side dry-run migration for remix without writing files", () => {
+    const cwd = createTempWorkspace("aurora-init-remix");
+    mkdirSync(join(cwd, "app", "routes"), { recursive: true });
+    writeFileSync(
+      join(cwd, "app", "routes", "_index.tsx"),
+      "export const loader = async () => ({ ok: true });\n",
+      "utf8",
+    );
+    writeFileSync(
+      join(cwd, "app", "routes", "blog.$slug.tsx"),
+      "export const action = async () => ({ ok: true });\n",
+      "utf8",
+    );
+
+    const result = runAuroraCli(
+      [
+        "init",
+        "--from",
+        "remix",
+        "--mode",
+        "side-by-side",
+        "--bridge",
+        "none",
+        "--out-dir",
+        "adoption",
+        "--dry-run",
+        "--format",
+        "json",
+      ],
+      { cwd },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const parsed = JSON.parse(result.stdout ?? "{}") as {
+      framework?: string;
+      migrationMode?: string;
+      bridge?: string;
+      dryRun?: boolean;
+      detectedRoutes?: number;
+      generatedFiles?: string[];
+    };
+
+    expect(parsed.framework).toBe("remix");
+    expect(parsed.migrationMode).toBe("side-by-side");
+    expect(parsed.bridge).toBe("none");
+    expect(parsed.dryRun).toBe(true);
+    expect(parsed.detectedRoutes).toBe(2);
+    expect(parsed.generatedFiles?.includes("incremental/mount.server.ts")).toBe(false);
+    expect(parsed.generatedFiles?.includes("interop/react-bridge.tsx")).toBe(false);
+    expect(existsSync(join(cwd, "adoption"))).toBe(false);
+  });
+
+  it("maps sveltekit routes to aurora route conventions", () => {
+    const cwd = createTempWorkspace("aurora-init-sveltekit");
+    mkdirSync(join(cwd, "src", "routes", "blog", "[slug]"), { recursive: true });
+    writeFileSync(join(cwd, "src", "routes", "+page.svelte"), "<h1>Home</h1>\n", "utf8");
+    writeFileSync(
+      join(cwd, "src", "routes", "blog", "[slug]", "+page.svelte"),
+      "<h1>Blog</h1>\n",
+      "utf8",
+    );
+
+    const result = runAuroraCli(
+      ["init", "--from", "sveltekit", "--dry-run"],
+      { cwd },
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("framework: sveltekit");
+    expect(result.stdout).toContain("/blog/:slug");
+    expect(result.stdout).toContain("output_files:");
+  });
+
+  it("validates required flags and rejects invalid options", () => {
+    const cwd = createTempWorkspace("aurora-init-errors");
+    mkdirSync(join(cwd, "pages"), { recursive: true });
+    writeFileSync(join(cwd, "pages", "index.tsx"), "export default function Home() { return null; }\n", "utf8");
+    mkdirSync(join(cwd, "existing"), { recursive: true });
+    writeFileSync(join(cwd, "existing", "file.txt"), "occupied\n", "utf8");
+
+    const missingFrom = runAuroraCli(["init"], { cwd });
+    const invalidFrom = runAuroraCli(["init", "--from", "gatsby"], { cwd });
+    const unknownOption = runAuroraCli(["init", "--from", "next", "--unknown"], {
+      cwd,
+    });
+    const occupiedOutDir = runAuroraCli(
+      ["init", "--from", "next", "--out-dir", "existing"],
+      { cwd },
+    );
+
+    expect(missingFrom.exitCode).toBe(2);
+    expect(missingFrom.stderr).toContain("--from is required");
+    expect(invalidFrom.exitCode).toBe(2);
+    expect(invalidFrom.stderr).toContain("invalid --from value 'gatsby'");
+    expect(unknownOption.exitCode).toBe(2);
+    expect(unknownOption.stderr).toContain("unknown option '--unknown'");
+    expect(occupiedOutDir.exitCode).toBe(2);
+    expect(occupiedOutDir.stderr).toContain("out-dir already exists and is not empty");
+  });
+});