@beignet/cli 0.0.31 → 0.0.33

package/dist/templates/testing.js

@@ -0,0 +1,542 @@
+export const testHelperTemplateFile = {
+    path: "lib/beignet-test.ts",
+    content: `import assert from "node:assert/strict";
+import {
+  after,
+  afterEach,
+  before,
+  beforeEach,
+  describe as nodeDescribe,
+  it as nodeIt,
+  test as nodeTest,
+} from "node:test";
+import { inspect, isDeepStrictEqual } from "node:util";
+
+export { after, afterEach, before, beforeEach };
+
+type TestBody = () => void | Promise<void>;
+type TestEach = {
+  <T>(cases: readonly T[]): (
+    name: string,
+    body: (value: T) => void | Promise<void>,
+  ) => void;
+  <T extends readonly unknown[]>(cases: readonly T[]): (
+    name: string,
+    body: (...values: T) => void | Promise<void>,
+  ) => void;
+};
+type TestRunner = ((name: string, body: TestBody) => unknown) & {
+  each: TestEach;
+  skip: (name: string, body: TestBody) => unknown;
+  skipIf: (condition: boolean) => TestRunner;
+};
+type NodeRunner = {
+  (name: string, body: TestBody): unknown;
+  (
+    name: string,
+    options: { skip?: boolean },
+    body: TestBody,
+  ): unknown;
+};
+
+type AsymmetricMatcher =
+  | { kind: "any"; expected: unknown }
+  | { kind: "arrayContaining"; expected: readonly unknown[] }
+  | { kind: "objectContaining"; expected: Record<string, unknown> };
+
+type BaseMatchers = {
+  toBe(expected: unknown): void;
+  toEqual(expected: unknown): void;
+  toMatchObject(expected: unknown): void;
+  toContain(expected: unknown): void;
+  toContainEqual(expected: unknown): void;
+  toHaveLength(expected: number): void;
+  toBeDefined(): void;
+  toBeUndefined(): void;
+  toBeNull(): void;
+  toBeGreaterThan(expected: number): void;
+  toMatch(expected: string | RegExp): void;
+  toThrow(expected?: string | RegExp | (new (...args: unknown[]) => object)): void;
+};
+
+type AsyncMatchers = {
+  toBe(expected: unknown): Promise<void>;
+  toEqual(expected: unknown): Promise<void>;
+  toMatchObject(expected: unknown): Promise<void>;
+  toBeNull(): Promise<void>;
+  toBeUndefined(): Promise<void>;
+  toThrow(expected?: string | RegExp | (new (...args: unknown[]) => object)): Promise<void>;
+};
+
+type Matchers = BaseMatchers & {
+  not: BaseMatchers;
+  resolves: AsyncMatchers;
+  rejects: AsyncMatchers;
+};
+
+type Expect = ((actual: unknown) => Matchers) & {
+  any(expected: unknown): AsymmetricMatcher;
+  arrayContaining(expected: readonly unknown[]): AsymmetricMatcher;
+  objectContaining(expected: Record<string, unknown>): AsymmetricMatcher;
+};
+
+export const describe = createRunner(nodeDescribe as NodeRunner);
+export const it = createRunner(nodeIt as NodeRunner);
+export const test = createRunner(nodeTest as NodeRunner);
+
+export const expect = Object.assign(
+  (actual: unknown) => createMatchers(actual),
+  {
+    any: (expected: unknown): AsymmetricMatcher => ({
+      kind: "any",
+      expected,
+    }),
+    arrayContaining: (expected: readonly unknown[]): AsymmetricMatcher => ({
+      kind: "arrayContaining",
+      expected,
+    }),
+    objectContaining: (
+      expected: Record<string, unknown>,
+    ): AsymmetricMatcher => ({ kind: "objectContaining", expected }),
+  },
+) satisfies Expect;
+
+function createRunner(
+  base: NodeRunner,
+  options?: { skip?: boolean },
+): TestRunner {
+  const runner = ((name: string, body: TestBody) =>
+    runTest(base, name, body, options)) as TestRunner;
+  runner.each = ((cases: readonly unknown[]) => {
+    return (
+      name: string,
+      body: (...values: unknown[]) => void | Promise<void>,
+    ) => {
+      for (const testCase of cases) {
+        const values = (
+          Array.isArray(testCase) ? testCase : [testCase]
+        ) as unknown[];
+        runTest(base, formatEachName(name, values), () => body(...values), options);
+      }
+    };
+  }) as TestEach;
+  runner.skip = (name: string, body: TestBody) =>
+    runTest(base, name, body, { skip: true });
+  runner.skipIf = (condition: boolean) =>
+    condition ? createRunner(base, { skip: true }) : runner;
+  return runner;
+}
+
+function runTest(
+  base: NodeRunner,
+  name: string,
+  body: TestBody,
+  options?: { skip?: boolean },
+): unknown {
+  return options ? base(name, options, body) : base(name, body);
+}
+
+function formatEachName(name: string, values: readonly unknown[]): string {
+  let index = 0;
+  return name.replace(/%[sdifoO]/g, () => formatInline(values[index++]));
+}
+
+function createMatchers(actual: unknown): Matchers {
+  return {
+    ...createBaseMatchers(actual, false),
+    not: createBaseMatchers(actual, true),
+    resolves: createAsyncMatchers(actual, "resolves"),
+    rejects: createAsyncMatchers(actual, "rejects"),
+  };
+}
+
+function createBaseMatchers(actual: unknown, negated: boolean): BaseMatchers {
+  return {
+    toBe(expected) {
+      check(
+        Object.is(actual, expected),
+        negated,
+        "Expected values to be identical.",
+      );
+    },
+    toEqual(expected) {
+      check(matchesExpected(actual, expected), negated, "Expected values to be equal.");
+    },
+    toMatchObject(expected) {
+      check(
+        matchesObject(actual, expected),
+        negated,
+        "Expected value to match object.",
+      );
+    },
+    toContain(expected) {
+      const matches =
+        typeof actual === "string"
+          ? actual.includes(String(expected))
+          : Array.isArray(actual) && actual.includes(expected);
+      check(matches, negated, "Expected value to contain item.");
+    },
+    toContainEqual(expected) {
+      check(
+        Array.isArray(actual) &&
+          actual.some((item) => matchesExpected(item, expected)),
+        negated,
+        "Expected array to contain equal item.",
+      );
+    },
+    toHaveLength(expected) {
+      const length =
+        actual !== null && typeof actual === "object"
+          ? (actual as { length?: unknown }).length
+          : undefined;
+      check(length === expected, negated, "Expected value to have length.");
+    },
+    toBeDefined() {
+      check(actual !== undefined, negated, "Expected value to be defined.");
+    },
+    toBeUndefined() {
+      check(actual === undefined, negated, "Expected value to be undefined.");
+    },
+    toBeNull() {
+      check(actual === null, negated, "Expected value to be null.");
+    },
+    toBeGreaterThan(expected) {
+      check(
+        typeof actual === "number" && actual > expected,
+        negated,
+        "Expected value to be greater than " + expected + ".",
+      );
+    },
+    toMatch(expected) {
+      const text = String(actual);
+      const matches =
+        typeof expected === "string" ? text.includes(expected) : expected.test(text);
+      check(matches, negated, "Expected value to match pattern.");
+    },
+    toThrow(expected) {
+      assert.equal(typeof actual, "function", "toThrow expects a function.");
+      let didThrow = false;
+      let thrown: unknown;
+      try {
+        (actual as () => unknown)();
+      } catch (error) {
+        didThrow = true;
+        thrown = error;
+      }
+      check(
+        didThrow && thrownMatches(thrown, expected),
+        negated,
+        "Expected function to throw.",
+      );
+    },
+  };
+}
+
+function createAsyncMatchers(
+  actual: unknown,
+  kind: "resolves" | "rejects",
+): AsyncMatchers {
+  const resolveActual = async () =>
+    kind === "resolves" ? await Promise.resolve(actual) : await rejected(actual);
+
+  return {
+    async toBe(expected) {
+      createBaseMatchers(await resolveActual(), false).toBe(expected);
+    },
+    async toEqual(expected) {
+      createBaseMatchers(await resolveActual(), false).toEqual(expected);
+    },
+    async toMatchObject(expected) {
+      createBaseMatchers(await resolveActual(), false).toMatchObject(expected);
+    },
+    async toBeNull() {
+      createBaseMatchers(await resolveActual(), false).toBeNull();
+    },
+    async toBeUndefined() {
+      createBaseMatchers(await resolveActual(), false).toBeUndefined();
+    },
+    async toThrow(expected) {
+      const thrown =
+        kind === "rejects" ? await rejected(actual) : await resolveActual();
+      check(
+        thrownMatches(thrown, expected),
+        false,
+        "Expected promise to reject with matching error.",
+      );
+    },
+  };
+}
+
+async function rejected(actual: unknown): Promise<unknown> {
+  try {
+    await Promise.resolve(actual);
+  } catch (error) {
+    return error;
+  }
+  assert.fail("Expected promise to reject.");
+}
+
+function check(condition: boolean, negated: boolean, message: string): void {
+  assert.ok(
+    negated ? !condition : condition,
+    negated ? "Negated assertion failed: " + message : message,
+  );
+}
+
+function matchesExpected(actual: unknown, expected: unknown): boolean {
+  if (!containsAsymmetric(expected)) {
+    return isDeepStrictEqual(actual, expected);
+  }
+
+  if (isAsymmetricMatcher(expected)) {
+    switch (expected.kind) {
+      case "any":
+        return matchesAny(actual, expected.expected);
+      case "arrayContaining":
+        return (
+          Array.isArray(actual) &&
+          expected.expected.every((expectedItem) =>
+            actual.some((actualItem) => matchesExpected(actualItem, expectedItem)),
+          )
+        );
+      case "objectContaining":
+        return matchesObject(actual, expected.expected);
+    }
+  }
+
+  if (Array.isArray(expected)) {
+    return (
+      Array.isArray(actual) &&
+      actual.length === expected.length &&
+      expected.every((item, index) => matchesExpected(actual[index], item))
+    );
+  }
+
+  if (isObjectRecord(expected)) {
+    if (!isObjectRecord(actual)) return false;
+    const actualKeys = Object.keys(actual);
+    const expectedKeys = Object.keys(expected);
+    return (
+      actualKeys.length === expectedKeys.length &&
+      expectedKeys.every(
+        (key) =>
+          Object.hasOwn(actual, key) &&
+          matchesExpected(actual[key], expected[key]),
+      )
+    );
+  }
+
+  return Object.is(actual, expected);
+}
+
+function matchesObject(actual: unknown, expected: unknown): boolean {
+  if (isAsymmetricMatcher(expected)) return matchesExpected(actual, expected);
+  if (Array.isArray(expected)) {
+    return (
+      Array.isArray(actual) &&
+      actual.length >= expected.length &&
+      expected.every((item, index) => matchesObject(actual[index], item))
+    );
+  }
+  if (!isObjectRecord(expected)) return matchesExpected(actual, expected);
+  if (!isObjectRecord(actual)) return false;
+  return Object.entries(expected).every(([key, expectedValue]) =>
+    matchesObject(actual[key], expectedValue),
+  );
+}
+
+function containsAsymmetric(value: unknown): boolean {
+  if (isAsymmetricMatcher(value)) return true;
+  if (Array.isArray(value)) return value.some(containsAsymmetric);
+  if (!isObjectRecord(value)) return false;
+  return Object.values(value).some(containsAsymmetric);
+}
+
+function isAsymmetricMatcher(value: unknown): value is AsymmetricMatcher {
+  return (
+    isObjectRecord(value) &&
+    (value.kind === "any" ||
+      value.kind === "arrayContaining" ||
+      value.kind === "objectContaining")
+  );
+}
+
+function matchesAny(actual: unknown, expected: unknown): boolean {
+  if (expected === String) return typeof actual === "string";
+  if (expected === Number) return typeof actual === "number";
+  if (expected === Boolean) return typeof actual === "boolean";
+  if (expected === Array) return Array.isArray(actual);
+  if (expected === Object) return isObjectRecord(actual);
+  if (expected instanceof Function) {
+    return actual instanceof (expected as new (...args: unknown[]) => object);
+  }
+  return actual !== undefined && actual !== null;
+}
+
+function thrownMatches(
+  error: unknown,
+  expected: string | RegExp | (new (...args: unknown[]) => object) | undefined,
+): boolean {
+  if (expected === undefined) return true;
+  if (typeof expected === "string") return errorMessage(error).includes(expected);
+  if (expected instanceof RegExp) return expected.test(errorMessage(error));
+  return error instanceof expected;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object";
+}
+
+function formatInline(value: unknown): string {
+  return typeof value === "string"
+    ? value
+    : inspect(value, { breakLength: Number.POSITIVE_INFINITY, depth: 2 });
+}
+`,
+};
+export const testRunnerTemplateFile = {
+    path: "lib/beignet-test-runner.ts",
+    content: `import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+
+const defaultTestRoots = [
+  "app",
+  "features",
+  "infra",
+  "lib",
+  "ports",
+  "server",
+  "tests",
+  "src/tests",
+];
+const ignoredDirectories = new Set([
+  ".beignet-local",
+  ".git",
+  ".next",
+  ".turbo",
+  "coverage",
+  "dist",
+  "node_modules",
+]);
+const testFilePattern = /\\.(test|spec)\\.[cm]?[tj]sx?$/;
+
+const explicitArgs = process.argv.slice(2);
+const testArgs =
+  explicitArgs.length > 0
+    ? resolveTestArgs(process.cwd(), explicitArgs)
+    : discoverTestFiles(process.cwd());
+
+if (testArgs.length === 0) {
+  console.log("No test files found.");
+  process.exit(0);
+}
+
+const result = spawnSync(
+  process.execPath,
+  ["--import", "tsx", "--test", ...testArgs],
+  {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: "inherit",
+  },
+);
+
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);
+
+function discoverTestFiles(cwd: string): string[] {
+  const files: string[] = [];
+  for (const root of testRoots(cwd)) {
+    const rootPath = path.join(cwd, root);
+    if (existsSync(rootPath)) {
+      walk(rootPath, cwd, files);
+    }
+  }
+  return files.sort();
+}
+
+function resolveTestArgs(cwd: string, args: string[]): string[] {
+  const resolved: string[] = [];
+  for (const arg of args) {
+    if (arg.startsWith("-")) {
+      resolved.push(arg);
+      continue;
+    }
+
+    const argPath = path.resolve(cwd, arg);
+    if (!existsSync(argPath)) {
+      resolved.push(arg);
+      continue;
+    }
+
+    const stats = statSync(argPath);
+    if (stats.isDirectory()) {
+      const files: string[] = [];
+      walk(argPath, cwd, files);
+      resolved.push(...files.sort());
+      continue;
+    }
+
+    resolved.push(path.relative(cwd, argPath).split(path.sep).join("/"));
+  }
+  return Array.from(new Set(resolved));
+}
+
+function testRoots(cwd: string): string[] {
+  return Array.from(new Set([...defaultTestRoots, ...configuredRoots(cwd)]));
+}
+
+function configuredRoots(cwd: string): string[] {
+  const configPath = path.join(cwd, "beignet.config.json");
+  if (!existsSync(configPath)) return [];
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf8")) as {
+      paths?: Record<string, string>;
+    };
+    const paths = config.paths ?? {};
+    return [
+      paths.tests,
+      paths.features,
+      paths.routes ? path.dirname(paths.routes) : undefined,
+      paths.server ? path.dirname(paths.server) : undefined,
+      paths.infrastructurePorts
+        ? path.dirname(paths.infrastructurePorts)
+        : undefined,
+      paths.ports ? path.dirname(paths.ports) : undefined,
+      paths.useCaseBuilder ? path.dirname(paths.useCaseBuilder) : undefined,
+    ].filter((root): root is string => Boolean(root) && root !== ".");
+  } catch {
+    return [];
+  }
+}
+
+function walk(directory: string, cwd: string, files: string[]): void {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (!ignoredDirectories.has(entry.name)) {
+        walk(entryPath, cwd, files);
+      }
+      continue;
+    }
+    if (entry.isFile() && testFilePattern.test(entry.name)) {
+      files.push(path.relative(cwd, entryPath).split(path.sep).join("/"));
+    }
+  }
+}
+`,
+};
+export const testSupportTemplateFiles = [
+    testHelperTemplateFile,
+    testRunnerTemplateFile,
+];
+//# sourceMappingURL=testing.js.map

package/dist/templates/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../../src/templates/testing.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,sBAAsB,GAAiB;IAClD,IAAI,EAAE,qBAAqB;IAC3B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4YV;CACA,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAiB;IAClD,IAAI,EAAE,4BAA4B;IAClC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqIV;CACA,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAmB;IACtD,sBAAsB;IACtB,sBAAsB;CACvB,CAAC"}

package/dist/templates/todos.js

@@ -359,7 +359,7 @@ export function createTestTodoRepository(): TodoRepository {
 	};
 }
 `,
-    useCaseTest: `import { describe, expect, it } from "bun:test";
+    useCaseTest: `import { describe, expect, it } from "@/lib/beignet-test";
 import { createUseCaseTester } from "@beignet/core/application";
 import { createTestUserActor } from "@beignet/core/ports/testing";
 import {
@@ -476,7 +476,7 @@ describe("todos use cases", () => {
 	});
 });
 `,
-    routesTest: `import { describe, expect, it } from "bun:test";
+    routesTest: `import { describe, expect, it } from "@/lib/beignet-test";
 import { createStaticAuth } from "@beignet/core/ports";
 import { createIdempotencyHooks, defineRoutes } from "@beignet/core/server";
 import { createTestPorts } from "@beignet/core/testing";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beignet/cli",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "type": "module",
   "description": "CLI for creating and maintaining Beignet apps.",
   "main": "./dist/lib.js",
@@ -65,10 +65,11 @@
   "devDependencies": {
     "@types/bun": "^1.3.13",
     "@types/node": "^20.10.0",
+    "next-themes": "^0.4.6",
     "typescript": "^5.3.0"
   },
   "dependencies": {
-    "@beignet/core": "^0.0.31",
+    "@beignet/core": "^0.0.33",
     "@clack/prompts": "^1.5.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@stricli/core": "^1.2.7",

package/skills/app-structure/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: app-structure
-description: "Maintain Beignet app structure with @beignet/cli: create starter output, make generators, full-slice feature recipes, db schema generation, beignet.config paths, routes inspection, lint dependency boundaries, doctor drift checks and fixes, MCP tools, generated AGENTS.md guidance, Intent package skills, and generated-app validation. Use when scaffolding, generating, fixing, or reviewing a Beignet app's structure."
+description: "Maintain Beignet app structure with @beignet/cli: create starter output, make generators, full-slice feature recipes, db schema sync, TenantScope resources, workflow registries, runtime-integrity manifests, beignet.config paths, routes inspection, lint dependency boundaries, doctor drift checks and fixes, MCP tools, generated AGENTS.md guidance, Intent package skills, and generated-app validation. Use when scaffolding, generating, fixing, or reviewing a Beignet app's structure."
 ---
 
 # Beignet CLI App Structure
@@ -63,12 +63,16 @@ Hand-written files do not run until registered:
 - schedules -> `server/schedules.ts`
 - tasks -> `server/tasks.ts`
 - outbox events/jobs -> `server/outbox.ts`
-- listeners -> `registerListeners(...)` in provider or infra wiring
+- listeners -> `server/listeners.ts` plus `registerListeners(...)` in server provider wiring
 - seeds -> the app-owned seed entrypoint, usually `server/seed.ts`
 
+When an app opts into runtime integrity, keep `server/runtime-integrity.ts`
+aligned with those central registries. The boot check is pure and
+serverless-safe: it compares declared listeners, schedules, tasks, and outbox
+artifacts against runtime registries before providers start.
+
 Run `beignet doctor --strict` after hand edits. Use `beignet doctor --fix` for
-low-risk route-group, schedule, task, and outbox registry repair; listener
-drift remains manual.
+low-risk route-group, schedule, task, outbox, and listener registry repair.
 
 ## Path Config
 
@@ -113,6 +117,10 @@ root at `src/client/index.ts`.
 - route-owned error catalog drift
 - misplaced workflow artifacts
 - unregistered schedules, tasks, outbox events/jobs, and listeners
+- runtime manifest and registry drift for apps that opt into boot integrity
+- tenant-scoped Drizzle repository drift, including generated `TenantScope`
+  boundaries, raw `tenantId` app-facing repository methods, and scoped
+  `tenantScopeId(scope)` predicates for tenant/workspace tables
 
 Fix structure or config instead of suppressing diagnostics.
 

package/src/check.ts

@@ -38,6 +38,8 @@ export type CheckAppOptions = {
   cwd?: string;
   fix?: boolean;
   color?: boolean;
+  /** Append a `beignet preflight` step after the doctor step. */
+  preflight?: boolean;
   /** Called after each step completes, for incremental progress output. */
   onStep?: (step: CheckStep) => void;
 };
@@ -69,6 +71,10 @@ export async function checkApp(
   const { step: doctorStep, fixes } = await runDoctorStep(targetDir, options);
   record(doctorStep);
 
+  if (options.preflight) {
+    record(await preflightStep(targetDir));
+  }
+
   const scripts = await readPackageScripts(targetDir);
   for (const script of scriptStepNames) {
     record(await scriptStep(targetDir, runner, script, scripts));
@@ -244,3 +250,20 @@ async function readPackageScripts(
   };
   return parsed.scripts ?? {};
 }
+
+async function preflightStep(targetDir: string): Promise<CheckStep> {
+  const startedAt = Date.now();
+  const { formatPreflight, runPreflight } = await import("./preflight.js");
+  const result = await runPreflight({ cwd: targetDir });
+  const failed = result.findings.some(
+    (finding) => finding.severity === "error",
+  );
+
+  return {
+    name: "beignet preflight",
+    command: "beignet preflight",
+    status: failed ? "failed" : "passed",
+    ...(failed ? { output: formatPreflight(result, targetDir) } : {}),
+    durationMs: Date.now() - startedAt,
+  };
+}