create-ailk 0.13.0 → 0.15.0

package/dist/lib/license-key-files.js

@@ -85,13 +85,18 @@ function upsertEnvLine(existing, key) {
  * `apps/api/.env` line (0600, other lines kept), and a `.gitignore` entry for
  * `ailk.key` when no existing line covers it. Idempotent — a second call with
  * the same key changes no byte.
+ *
+ * `apiEnv: false` skips the `apps/api/.env` line — a spoke (#7426 D6) has no
+ * `apps/api`, so it keeps the key in `ailk.key` alone.
  */
-export function writeLicenseKeyFiles(dir, key) {
+export function writeLicenseKeyFiles(dir, key, opts = {}) {
     assertLicenseKeyShape(key);
     writeOwnerOnly(join(dir, LICENSE_KEY_FILE), `${key}\n`);
-    const envPath = join(dir, LICENSE_ENV_FILE);
-    const env = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
-    writeOwnerOnly(envPath, upsertEnvLine(env, key));
+    if (opts.apiEnv !== false) {
+        const envPath = join(dir, LICENSE_ENV_FILE);
+        const env = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
+        writeOwnerOnly(envPath, upsertEnvLine(env, key));
+    }
     const ignorePath = join(dir, ".gitignore");
     const ignore = existsSync(ignorePath) ? readFileSync(ignorePath, "utf8") : "";
     const covered = ignore

package/dist/lib/module-license-gate.d.ts

@@ -139,6 +139,15 @@ export declare function deriveLevel(options: GateOptions): Promise<{
     level: Level;
     bundles: Map<ModuleName, Uint8Array>;
 }>;
+/**
+ * The level a `--modules`-keep run's chosen non-Free design is gated on
+ * (#7010). `resolveModuleSet`'s keep branch composes no level (NFR-2), so
+ * `scaffold()` derives one here through `deriveLevel`, as the addition branch
+ * does. A key the registry refuses for a Pro module — lapsed, revoked, or one
+ * that does not cover Pro — reads as `"free"`, so `assertDesignAllowed`
+ * refuses with its own message (fail closed); any other failure propagates.
+ */
+export declare function deriveDesignLevel(options: GateOptions): Promise<Level>;
 /**
  * The one entry point that turns `--modules` + the key into the effective
  * module set and its resolved bundles (D5) — `programmatic.ts`'s `scaffold()`

package/dist/lib/module-license-gate.js

@@ -294,6 +294,24 @@ export async function deriveLevel(options) {
         throw err;
     }
 }
+/**
+ * The level a `--modules`-keep run's chosen non-Free design is gated on
+ * (#7010). `resolveModuleSet`'s keep branch composes no level (NFR-2), so
+ * `scaffold()` derives one here through `deriveLevel`, as the addition branch
+ * does. A key the registry refuses for a Pro module — lapsed, revoked, or one
+ * that does not cover Pro — reads as `"free"`, so `assertDesignAllowed`
+ * refuses with its own message (fail closed); any other failure propagates.
+ */
+export async function deriveDesignLevel(options) {
+    try {
+        return (await deriveLevel(options)).level;
+    }
+    catch (err) {
+        if (err instanceof LicenseRequiredError)
+            return "free";
+        throw err;
+    }
+}
 /**
  * The one entry point that turns `--modules` + the key into the effective
  * module set and its resolved bundles (D5) — `programmatic.ts`'s `scaffold()`

package/dist/module-architecture.d.ts

@@ -83,6 +83,15 @@ export interface PageRosterRow {
  * scaffold carries (#6940).
  */
 export interface ModuleSlice {
+    /**
+     * Admits the module on a spoke (`create-ailk --topology spoke`, #7426 D7).
+     * `true` → a spoke may carry it, and its bundle installs through the spoke
+     * filter (`topology.ts` `isSpokeExcluded`), so any `apps/api` or
+     * `database` part it carries is dropped. Unset → refused on a spoke.
+     * `topology.ts` `spokeModules()` reads it; a sibling issue admits its
+     * module by setting it here, never in a second list.
+     */
+    spoke?: true;
     /**
      * The paid UI package base-tree code loads through
      * `apps/web/lib/paid-sections.generated.ts` (#7536). Present → one row in the

package/dist/module-architecture.js

@@ -206,6 +206,7 @@ function payloadPaths(kind, name, destRoot) {
 export const MODULE_SLICES = {
     // ── marketing — thin presentation module (the default) ───────────────────
     marketing: {
+        spoke: true,
         webImports: [
             WEB_AUTH_ADAPTER_IMPORT,
             "packages/content-adapters",
@@ -287,6 +288,7 @@ export const MODULE_SLICES = {
     },
     // ── docs-blog — Pro module: both fumadocs surfaces (D-46) ────────────────
     "docs-blog": {
+        spoke: true,
         webImports: [WEB_AUTH_ADAPTER_IMPORT, "packages/fumadocs-schema"],
         packages: {
             "fumadocs-schema": {
@@ -1388,6 +1390,10 @@ export const MODULE_SLICES = {
             "apps/api/src/bin/deliverable-upload.ts",
             "apps/api/src/bin/session-retention-sweep.ts",
             "apps/api/src/bin/seed-presets.ts",
+            // #7844 D7 — the operator flow-copy CLI and its service: flows code by
+            // subject, and a Free scaffold carries no flows.
+            "apps/api/src/bin/flows-copy.ts",
+            "apps/api/src/services/flow-copy.ts",
             "apps/api/src/bin/listing-csv-sweep.ts",
             "apps/api/src/bin/followup-sweep.ts",
             "apps/api/src/bin/seed-waitlist-experiments.ts",

package/dist/parse-args.d.ts

@@ -26,6 +26,15 @@ export declare const RESERVED_SHAPES: readonly ["local-business-product"];
 /** The `--design` vocabulary (#6754 D1) — `STARTER_DESIGNS`, pinned by test. */
 export declare const RECOGNIZED_DESIGNS: readonly ["standard", "minimalism"];
 export type DesignName = (typeof RECOGNIZED_DESIGNS)[number];
+/**
+ * The `--topology` vocabulary (#7426 D1) — orthogonal to `--shape`: any shape
+ * can be scaffolded as either. Declared here rather than imported from
+ * `topology.ts` for the reason `RECOGNIZED_MODULES` is: that module reads
+ * `MODULE_SLICES`, and importing it here closes a runtime cycle through
+ * `lib/module-tier.ts`. `spoke-topology.test.ts` pins the two lists equal.
+ */
+export declare const RECOGNIZED_TOPOLOGIES: readonly ["hub", "spoke"];
+export type TopologyName = (typeof RECOGNIZED_TOPOLOGIES)[number];
 export interface CliOptions {
     /** Positional target directory (the dir to scaffold into). Optional only
      *  when `help` or `version` is set. */
@@ -94,6 +103,19 @@ export interface CliOptions {
      * flag is.
      */
     license?: string;
+    /**
+     * The scaffold's topology (`--topology`, #7426 D1). `hub` — the default,
+     * and the only value before #7426 — unless `--topology spoke`.
+     */
+    topology: TopologyName;
+    /**
+     * The raw `--hub-url` value (#7426 D2), present only on a spoke run that
+     * passed it. `scaffold()` validates and normalizes it, falling back to
+     * `AILK_API_URL`.
+     */
+    hubUrl?: string;
+    /** Spoke only: `false` with `--without-mcp` (#7426 D3), else `true`. */
+    mcp?: boolean;
 }
 export declare class ParseError extends Error {
     constructor(message: string);

package/dist/parse-args.js

@@ -59,6 +59,14 @@ const SHAPE_DESCRIPTIONS = {
     "person-service": "a person selling their own service",
 };
 const SHAPE_LIST = RECOGNIZED_SHAPES.join(", ");
+/**
+ * The `--topology` vocabulary (#7426 D1) — orthogonal to `--shape`: any shape
+ * can be scaffolded as either. Declared here rather than imported from
+ * `topology.ts` for the reason `RECOGNIZED_MODULES` is: that module reads
+ * `MODULE_SLICES`, and importing it here closes a runtime cycle through
+ * `lib/module-tier.ts`. `spoke-topology.test.ts` pins the two lists equal.
+ */
+export const RECOGNIZED_TOPOLOGIES = ["hub", "spoke"];
 export class ParseError extends Error {
     constructor(message) {
         super(message);
@@ -158,6 +166,18 @@ Options:
   --license <key>          Your licence key: fetch paid modules with it and
                            write it into the scaffold (apps/api/.env and a
                            gitignored ailk.key, both owner-only).
+  --topology <hub|spoke>   hub (the default) scaffolds the whole site: web,
+                           API, MCP and database. spoke scaffolds a web-only
+                           site that sends its forms, flows and listings to a
+                           hub — no apps/api, no database, no sign-in, and
+                           apps/mcp kept as a stateless front. Composes with
+                           any --shape or --template. A spoke carries
+                           marketing and docs-blog.
+  --hub-url <origin>       A spoke's hub, e.g. https://hub.example.com (https:,
+                           or http: on localhost). Defaults to AILK_API_URL;
+                           a spoke with neither is refused. Written to
+                           apps/web/.env.local — the spoke key never is.
+  --without-mcp            A spoke without apps/mcp.
   --install                After scaffolding, run \`pnpm install\` in the
                            target directory. Off by default.
   --help, -h               Print this message.
@@ -194,6 +214,9 @@ export function parseCliArgs(argv, env = { interactive: false }) {
                 shape: { type: "string" },
                 design: { type: "string" },
                 license: { type: "string" },
+                topology: { type: "string" },
+                "hub-url": { type: "string" },
+                "without-mcp": { type: "boolean", default: false },
                 surfaces: { type: "string" },
                 "sync-architecture": { type: "string" },
                 "sync-catalog": { type: "boolean", default: false },
@@ -224,6 +247,10 @@ export function parseCliArgs(argv, env = { interactive: false }) {
     const syncClaudeMd = parsed.values["sync-claude-md"] === true;
     const withCatalog = parsed.values["with-catalog"] === true;
     const license = parseLicense(parsed.values.license);
+    const rawTopology = parsed.values.topology;
+    const topology = parseTopology(rawTopology);
+    const hubUrl = parsed.values["hub-url"];
+    const withoutMcp = parsed.values["without-mcp"] === true;
     // The sync modes each exit after rewriting their one file, so asking for
     // more than one in one invocation has no coherent meaning.
     const syncFlags = [
@@ -234,6 +261,21 @@ export function parseCliArgs(argv, env = { interactive: false }) {
     if (syncFlags.length > 1) {
         throw new ParseError(`${syncFlags.join(" and ")} cannot be combined; run them one at a time`);
     }
+    // #7426 D1 — a sync reads the topology from the site's manifest; naming one
+    // here has no coherent meaning.
+    if (rawTopology !== undefined && syncFlags.length > 0) {
+        throw new ParseError(`--topology cannot be combined with ${syncFlags[0]}: a sync reads the site's topology from its .ailk-site-manifest.json`);
+    }
+    // #7426 D2/D3 — the spoke-only flags.
+    if (topology !== "spoke") {
+        const spokeOnly = [
+            hubUrl !== undefined ? "--hub-url" : undefined,
+            withoutMcp ? "--without-mcp" : undefined,
+        ].filter((f) => f !== undefined);
+        if (spokeOnly.length > 0) {
+            throw new ParseError(`${spokeOnly.join(" and ")} only apply${spokeOnly.length === 1 ? "s" : ""} to a spoke. Pass --topology spoke, or drop ${spokeOnly.length === 1 ? "it" : "them"}.`);
+        }
+    }
     // Validate the sync-architecture value now, through the SAME parseModules
     // path `--modules` uses, so an unknown module throws ParseError at parse time
     // (cli.ts re-parses the raw value to the module list in sync mode).
@@ -255,6 +297,7 @@ export function parseCliArgs(argv, env = { interactive: false }) {
             syncClaudeMd: false,
             withCatalog: false,
             syncArchitecture: undefined,
+            topology: "hub",
         };
     }
     // Sync modes: the target dir is optional (positional if given, else cwd).
@@ -275,6 +318,7 @@ export function parseCliArgs(argv, env = { interactive: false }) {
             syncClaudeMd,
             withCatalog,
             syncArchitecture,
+            topology: "hub",
         };
     }
     if (parsed.positionals.length === 0) {
@@ -292,6 +336,13 @@ export function parseCliArgs(argv, env = { interactive: false }) {
                 : "--design";
         throw new ParseError(`--template cannot be combined with ${flags}: a template already fixes its shape and design. Pass --template alone, or --shape with an optional --design.`);
     }
+    // #7426 D2 — a spoke needs its hub's origin. Presence only, here: the value
+    // is validated and normalized by `scaffold()` (`topology.ts`
+    // `normalizeHubUrl`), still before the target directory exists.
+    if (topology === "spoke" &&
+        (hubUrl ?? process.env["AILK_API_URL"] ?? "").trim() === "") {
+        throw new ParseError("a spoke needs its hub's origin, and none was given. Pass --hub-url <origin>, or set AILK_API_URL (e.g. https://hub.example.com).");
+    }
     // R1 — no silent default: with neither a template nor a shape, ask on a
     // terminal and refuse without one.
     const needsShapePrompt = template === undefined && shape === undefined;
@@ -314,8 +365,22 @@ export function parseCliArgs(argv, env = { interactive: false }) {
         withCatalog,
         syncArchitecture: undefined,
         ...(license !== undefined ? { license } : {}),
+        topology,
+        ...(topology === "spoke"
+            ? { ...(hubUrl !== undefined ? { hubUrl } : {}), mcp: !withoutMcp }
+            : {}),
     };
 }
+/** Validate `--topology` (#7426 D1): `hub` when absent, trimmed and lowercased. */
+function parseTopology(raw) {
+    if (raw === undefined)
+        return "hub";
+    const name = raw.trim().toLowerCase();
+    if (!RECOGNIZED_TOPOLOGIES.includes(name)) {
+        throw new ParseError(`unknown topology "${raw}". Recognized: ${RECOGNIZED_TOPOLOGIES.join(", ")}`);
+    }
+    return name;
+}
 /**
  * Validate `--shape` (#6754 D2 step 2): trimmed and lowercased. A reserved
  * shape is refusal R2; any other unrecognized value names the recognized set.
@@ -467,6 +532,14 @@ export function toScaffoldOptions(opts) {
         ...(opts.shape !== undefined ? { shape: opts.shape } : {}),
         ...(opts.design !== undefined ? { design: opts.design } : {}),
         ...(opts.license !== undefined ? { license: opts.license } : {}),
+        // #7426 — a hub run hands `scaffold()` the object it did before.
+        ...(opts.topology === "spoke"
+            ? {
+                topology: "spoke",
+                ...(opts.hubUrl !== undefined ? { hubUrl: opts.hubUrl } : {}),
+                mcp: opts.mcp !== false,
+            }
+            : {}),
     };
 }
 /**

package/dist/programmatic.d.ts

@@ -22,6 +22,7 @@ import { type ModuleName } from "./parse-args.js";
 import { type TemplateLayout } from "./site-chrome.js";
 import { type SyncRoutesResult } from "./sync-routes.js";
 import { type StarterShape } from "./template-manifest.js";
+import { type Topology } from "./topology.js";
 export interface ScaffoldOptions {
     /** Absolute or relative path to the target directory. Must not exist or be empty. */
     targetDir: string;
@@ -136,6 +137,18 @@ export interface ScaffoldOptions {
      * code registry that has since been deleted (#6638's per-name table).
      */
     designLayout?: TemplateLayout;
+    /**
+     * The scaffold's topology (`--topology`, #7426 D1). `"hub"` — the default
+     * — is the whole site. `"spoke"` is the same scaffold with nodes removed
+     * (`topology.ts`): no `apps/api`, no `database/`, no sign-in, `apps/mcp`
+     * a stateless front unless `mcp: false`. A spoke needs a `template` or a
+     * `shape` (the manifest records the topology) and a hub origin.
+     */
+    topology?: Topology;
+    /** A spoke's hub origin (`--hub-url`), else `AILK_API_URL` (#7426 D2). */
+    hubUrl?: string;
+    /** Spoke only: `false` drops `apps/mcp` (`--without-mcp`, #7426 D3). Default true. */
+    mcp?: boolean;
 }
 export interface ScaffoldResult {
     /** Resolved absolute path to the scaffolded directory. */
@@ -161,6 +174,13 @@ export interface ScaffoldResult {
      * a keyed run with no `--modules` carries the key's derived level here.
      */
     modules: ModuleName[];
+    /**
+     * A spoke only (#7426 D7): modules the key's default set carried that a
+     * spoke does not admit, dropped from this scaffold. Absent when none were.
+     */
+    droppedModules?: ModuleName[];
+    /** A spoke only (#7426 D2): the normalized hub origin written to apps/web/.env.local. */
+    hubOrigin?: string;
 }
 /**
  * Scaffold an AI Launch Kit starter project into targetDir (synchronous).