@cosmicdrift/kumiko-dev-server 0.329.0 → 0.330.2

package/dist/env-schema.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod";
+/** Env-vars read by framework-core (api/server, db/connection,
+ *  dev-server/run-prod-app). NOT including feature-specific vars.
+ *
+ *  PORT-default "3000" is the same fallback as
+ *  `packages/dev-server/src/run-prod-app.ts:533` — keep in sync when the
+ *  call-site is refactored to consume parsed env (Sprint 9.5 Phase 4). */
+export declare const frameworkCoreEnvSchema: z.ZodObject<{
+    PORT: z.ZodDefault<z.ZodString>;
+    DATABASE_URL: z.ZodURL;
+    REDIS_URL: z.ZodURL;
+    KUMIKO_INSTANCE_ID: z.ZodOptional<z.ZodString>;
+    KUMIKO_SKIP_ES_OPS: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FrameworkCoreEnv = z.infer<typeof frameworkCoreEnvSchema>;

package/dist/env-schema.js

@@ -0,0 +1,60 @@
+// @runtime runtime
+// Consumed at prod boot via composeEnvSchema (same as compose-stacks),
+// not only by tooling — keep runtime-isolation-safe (kumiko-framework#2340).
+//
+// Framework-core env-schema — the vars that runProdApp + buildServer
+// + the connection-pool read directly from process.env today. Apps merge
+// this into their app-wide schema via `composeEnvSchema({ core, ... })`.
+//
+// Sprint 9.2 is purely additive: the schema is exposed, but the call-sites
+// in run-prod-app.ts (requireEnv("DATABASE_URL"), …) and api/server.ts
+// (process.env["KUMIKO_INSTANCE_ID"]) keep reading process.env directly.
+// Apps that opt into the schema get aggregated boot-validation errors
+// BEFORE those legacy reads run; apps that don't, behave as before.
+//
+// Feature-specific vars (JWT_SECRET, KUMIKO_SECRETS_MASTER_KEY_*) live
+// in their owning feature's envSchema — Phase 2 (bundled-features).
+import * as z from "zod";
+/** Env-vars read by framework-core (api/server, db/connection,
+ *  dev-server/run-prod-app). NOT including feature-specific vars.
+ *
+ *  PORT-default "3000" is the same fallback as
+ *  `packages/dev-server/src/run-prod-app.ts:533` — keep in sync when the
+ *  call-site is refactored to consume parsed env (Sprint 9.5 Phase 4). */
+export const frameworkCoreEnvSchema = z.object({
+    PORT: z
+        .string()
+        .regex(/^\d+$/, "PORT must be a positive integer string")
+        .default("3000")
+        .describe("HTTP listen port. runProdApp defaults to 3000 when unset."),
+    DATABASE_URL: z
+        // `protocol` is matched against the URL scheme without the trailing
+        // colon — `postgres://`/`postgresql://` pass, `https://`/`ftp://` are
+        // rejected so the error message's promise actually holds at boot.
+        .url({ protocol: /^postgres(ql)?$/, error: "DATABASE_URL must be a valid postgres:// URL" })
+        .describe("Primary Postgres connection string (write + read).")
+        .meta({ kumiko: { pulumi: { secret: true } } }),
+    REDIS_URL: z
+        // `redis://` + the TLS variant `rediss://` pass; other schemes reject.
+        .url({ protocol: /^rediss?$/, error: "REDIS_URL must be a valid redis:// URL" })
+        .describe("Redis connection string for SSE-broker + job-queues.")
+        .meta({ kumiko: { pulumi: { secret: true } } }),
+    KUMIKO_INSTANCE_ID: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Stable per-process identifier (pod name, hostname). " +
+        "Multi-instance deploys SHOULD set this so per-instance consumers " +
+        "(SSE) don't accumulate orphaned cursor-rows on restart."),
+    // `z.string().optional()` (not `z.literal("1")`) — the run-prod-app
+    // call-site (`envSource["KUMIKO_SKIP_ES_OPS"] !== "1"`) ignores any
+    // value other than literal "1". A stricter schema would reject e.g.
+    // "true" / "yes" that the runtime silently ignores, surfacing
+    // boot-errors for inputs the framework doesn't actually care about.
+    KUMIKO_SKIP_ES_OPS: z
+        .string()
+        .optional()
+        .describe("Set to '1' to skip event-store ops (seed/migrate) at boot. " +
+        "Any other value is treated as 'not set' by run-prod-app. " +
+        "Used by integration-test stacks that manage ES-ops out-of-band."),
+});

package/dist/few-shot-corpus.d.ts

@@ -0,0 +1,72 @@
+import { type FeaturePattern, type ParseError } from "@cosmicdrift/kumiko-framework/engine";
+export type AuthoringStyle = "canonical" | "legacy";
+export type CorpusWarning = {
+    /** Repo-relative path to the file that triggered the warning. */
+    readonly sourcePath: string;
+    /** Human-readable explanation. Currently only "parser-throw" but
+     *  kept open-ended so future builders can add more (e.g.
+     *  "duplicate-id", "no-feature-name"). */
+    readonly message: string;
+};
+export type FewShotEntry = {
+    /** Stable id derived from the path (`samples/recipes/basic-entity`). */
+    readonly id: string;
+    /** Repo-relative path to the feature-file. */
+    readonly sourcePath: string;
+    /** Repo-relative path to the workspace package.json (for description lookup). */
+    readonly packageJsonPath: string | undefined;
+    /** Workspace name (`@cosmicdrift/kumiko-sample-basic-entity`). */
+    readonly packageName: string | undefined;
+    /** English description from package.json. */
+    readonly description: string | undefined;
+    /** Feature name from `defineFeature("...", ...)`. Undefined if the
+     *  parser couldn't read it (rare — implies a non-feature file got
+     *  picked up). */
+    readonly featureName: string | undefined;
+    /** Pattern-categories present in this feature, deduplicated. Useful
+     *  as topic-tags for retrieval ("show me cross-cutting examples"). */
+    readonly tags: readonly string[];
+    /** Counts per pattern-kind — quick stats without scanning the
+     *  patterns array. */
+    readonly patternsByKind: Readonly<Record<string, number>>;
+    /** All parsed patterns. Same shape the parser emits. */
+    readonly patterns: readonly FeaturePattern[];
+    /** Errors the parser raised. Empty for canonical-form features. */
+    readonly parseErrors: readonly ParseError[];
+    /** `canonical` (clean parse) or `legacy` (parser couldn't read it
+     *  fully — Factory-style / identifier-refs). */
+    readonly authoringStyle: AuthoringStyle;
+    /** Raw source text — kept verbatim so the LLM can train on the
+     *  exact byte-form, including comments + whitespace. */
+    readonly rawSource: string;
+};
+export type FewShotCorpus = {
+    /** ISO-instant when the corpus was generated. */
+    readonly generatedAt: string;
+    /** Total entry count, broken down by authoringStyle for quick stats. */
+    readonly totals: {
+        readonly all: number;
+        readonly canonical: number;
+        readonly legacy: number;
+    };
+    readonly entries: readonly FewShotEntry[];
+    /** Files that were discovered but couldn't be turned into entries.
+     *  Surfaces parser crashes + duplicate-id collisions instead of
+     *  swallowing them — the regenerate-script reports these to the user
+     *  and the drift-test asserts the count stays constant. */
+    readonly warnings: readonly CorpusWarning[];
+};
+export type BuildFewShotCorpusOptions = {
+    /** Repo root — used for relative-path output and security guards. */
+    readonly repoRoot: string;
+    /** Folders to scan recursively. Defaults to samples/* + bundled-features. */
+    readonly scanRoots?: readonly string[];
+};
+export declare function buildFewShotCorpus(options: BuildFewShotCorpusOptions): FewShotCorpus;
+/**
+ * Stable id from the source path. Drops the leading `samples/` or
+ * `packages/` prefix and the trailing `/src/feature.ts` suffix so the
+ * id reads like the canonical short name (`basic-entity`,
+ * `bundled-features/auth-email-password`).
+ */
+export declare function pathToId(sourcePath: string): string;

package/dist/few-shot-corpus.js

@@ -0,0 +1,262 @@
+// buildFewShotCorpus — extracts feature-files from the repo into a
+// structured JSON corpus that L2 (Prompt-Pipeline) feeds into the LLM
+// at generation time. One entry per feature-file, four data sources
+// per entry: raw source text, package.json description, parsed
+// FeaturePattern[], plus pattern-categories from the C4 library.
+//
+// **Why a checked-in JSON file (docs/few-shot-corpus.json):**
+//   - Offline-consumable: AI-Builder can prompt without re-parsing
+//     30+ feature files at request time.
+//   - Diff-reviewable: when a feature changes, the corpus diff shows
+//     up in the PR — humans see how the example surface shifted.
+//   - Portable: the corpus is a flat JSON, can ship to a hosted LLM
+//     service / fine-tuning pipeline / customer environment without
+//     dragging the framework's parser along.
+//
+// **Authoring-Style classification:**
+//   - `canonical` → 0 ParseErrors. The example is "do it like this"
+//     for the LLM.
+//   - `legacy` → has ParseErrors. The example shows what code looks
+//     like in the wild (Factory-style, identifier-refs) and is useful
+//     for understanding intent — but the LLM should NOT replicate
+//     this style. L2 marks legacy entries as "do not generate".
+//
+// **Why the corpus includes legacy entries but the Designer does not:**
+//   The two consumers want different slices of the same data. L2 needs
+//   counter-examples (showing the LLM what *not* to emit raises the
+//   chance of clean output), so legacy entries are kept and tagged.
+//   The Designer can only round-trip canonical-form patterns through
+//   the AST-Patcher — legacy entries would render as read-only with
+//   no edit affordance, which is worse than hiding them. So the corpus
+//   builder is permissive, and the Designer filters at read-time.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { PATTERN_LIBRARY, parseFeatureFile, } from "@cosmicdrift/kumiko-framework/engine";
+// =============================================================================
+// Builder
+// =============================================================================
+const FEATURE_FILE_PATTERN = /(?:^|\/)(feature|.*\.feature)\.ts$/;
+const DEFAULT_SCAN_ROOTS = [
+    "samples/recipes",
+    "samples/apps",
+    "samples/showcases",
+    "packages/bundled-features/src",
+];
+// Static timestamp keeps the JSON output deterministic across CI runs —
+// the regenerate-script could overwrite this with a real timestamp,
+// but drift-tests compare structural data, not timestamps. Centralized
+// here so the build path and any future inspector use the same value.
+const STATIC_GENERATED_AT = "1970-01-01T00:00:00Z";
+export function buildFewShotCorpus(options) {
+    const repoRoot = resolve(options.repoRoot);
+    const scanRoots = (options.scanRoots ?? DEFAULT_SCAN_ROOTS).map((r) => resolve(repoRoot, r));
+    const featureFiles = [];
+    for (const root of scanRoots) {
+        if (!existsSync(root))
+            continue;
+        walkDir(root, featureFiles);
+    }
+    featureFiles.sort();
+    const entries = [];
+    const warnings = [];
+    const seenIds = new Map();
+    for (const filePath of featureFiles) {
+        const result = buildEntry(filePath, repoRoot);
+        if (result.warning) {
+            warnings.push(result.warning);
+            continue;
+        }
+        const entry = result.entry;
+        const previousPath = seenIds.get(entry.id);
+        if (previousPath) {
+            // Two feature-files mapped to the same id. The corpus uses ids
+            // for retrieval — duplicates would silently overwrite each other
+            // in any consumer that built a Map<id, entry>. Surface as a
+            // warning, drop the second occurrence.
+            warnings.push({
+                sourcePath: entry.sourcePath,
+                message: `duplicate-id: collides with ${previousPath}`,
+            });
+            continue;
+        }
+        seenIds.set(entry.id, entry.sourcePath);
+        entries.push(entry);
+    }
+    const canonical = entries.filter((e) => e.authoringStyle === "canonical").length;
+    return {
+        generatedAt: STATIC_GENERATED_AT,
+        totals: {
+            all: entries.length,
+            canonical,
+            legacy: entries.length - canonical,
+        },
+        entries,
+        warnings,
+    };
+}
+function buildEntry(filePath, repoRoot) {
+    const sourcePath = relative(repoRoot, filePath);
+    let parsed;
+    try {
+        parsed = parseFeatureFile(filePath);
+    }
+    catch (err) {
+        // ts-morph couldn't read the file (syntax-error, IO problem, weird
+        // encoding). Skip the entry but record *why* — silent skip used to
+        // hide newly broken feature-files until L2 hit them.
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+            warning: { sourcePath, message: `parser-throw: ${detail}` },
+        };
+    }
+    const rawSource = readFileSync(filePath, "utf8");
+    const id = pathToId(sourcePath);
+    const pkgInfo = findPackageJson(filePath, repoRoot);
+    const tags = collectTags(parsed.patterns);
+    const patternsByKind = countPatternsByKind(parsed.patterns);
+    const authoringStyle = parsed.errors.length === 0 ? "canonical" : "legacy";
+    // SourceLocation.file is an absolute path coming out of the parser —
+    // strip it to repo-relative so the corpus diff stays stable across
+    // machines / CI runners. Same for ParseError.source.file.
+    const patterns = parsed.patterns.map((p) => relativizeSources(p, repoRoot));
+    const parseErrors = parsed.errors.map((e) => ({
+        ...e,
+        source: { ...e.source, file: relative(repoRoot, e.source.file) },
+    }));
+    return {
+        entry: {
+            id,
+            sourcePath,
+            packageJsonPath: pkgInfo?.relPath,
+            packageName: pkgInfo?.name,
+            description: pkgInfo?.description,
+            featureName: parsed.featureName,
+            tags,
+            patternsByKind,
+            patterns,
+            parseErrors,
+            authoringStyle,
+            rawSource,
+        },
+    };
+}
+/**
+ * Recursively walk a value and rewrite every nested SourceLocation's
+ * `file` field to be repo-relative. Identifies SourceLocation by
+ * structural shape (`{ file, start, end, raw }`) rather than by
+ * type-tag — the parsed objects are plain JSON-ish at this point and
+ * a discriminator would complicate the renderer.
+ *
+ * Typed `unknown → unknown` so the walker stays honest about what it
+ * sees. The single boundary cast lives at the call site
+ * (`as FeaturePattern`) where the input contract is known.
+ */
+function relativizeSources(value, repoRoot) {
+    if (Array.isArray(value)) {
+        return value.map((v) => relativizeSources(v, repoRoot));
+    }
+    if (value && typeof value === "object") {
+        const obj = value;
+        if (typeof obj["file"] === "string" &&
+            typeof obj["raw"] === "string" &&
+            typeof obj["start"] === "object" &&
+            typeof obj["end"] === "object") {
+            return { ...obj, file: relative(repoRoot, obj["file"]) };
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            out[k] = relativizeSources(v, repoRoot);
+        }
+        return out;
+    }
+    return value;
+}
+// =============================================================================
+// Helpers
+// =============================================================================
+/**
+ * Stable id from the source path. Drops the leading `samples/` or
+ * `packages/` prefix and the trailing `/src/feature.ts` suffix so the
+ * id reads like the canonical short name (`basic-entity`,
+ * `bundled-features/auth-email-password`).
+ */
+export function pathToId(sourcePath) {
+    return sourcePath
+        .replace(/^(samples|packages)\//, "")
+        .replace(/\/src\/feature\.ts$/, "")
+        .replace(/\/feature\.ts$/, "");
+}
+function walkDir(dir, acc) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        // skip: directory missing/unreadable, nothing to walk
+        return;
+    }
+    for (const entry of entries) {
+        const name = String(entry.name);
+        const full = join(dir, name);
+        if (entry.isDirectory()) {
+            if (name === "node_modules" || name === "dist" || name === "dist-server")
+                continue;
+            if (name.startsWith("."))
+                continue;
+            walkDir(full, acc);
+        }
+        else if (entry.isFile() && FEATURE_FILE_PATTERN.test(full)) {
+            acc.push(full);
+        }
+    }
+}
+/**
+ * Walk upward from `featureFile` to find the nearest `package.json` and
+ * pluck name + description out of it. Stops at `repoRoot`.
+ */
+function findPackageJson(featureFile, repoRoot) {
+    let dir = dirname(featureFile);
+    const stopAt = resolve(repoRoot);
+    while (true) {
+        const candidate = join(dir, "package.json");
+        if (existsSync(candidate)) {
+            try {
+                const pkg = JSON.parse(readFileSync(candidate, "utf8"));
+                return {
+                    relPath: relative(repoRoot, candidate),
+                    name: typeof pkg.name === "string" ? pkg.name : undefined,
+                    description: typeof pkg.description === "string" ? pkg.description : undefined,
+                };
+            }
+            catch {
+                // Malformed package.json — keep walking up.
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir || dir === stopAt)
+            return undefined;
+        dir = parent;
+    }
+}
+/**
+ * Collect the union of pattern-categories present in the feature.
+ * Categories come from the pattern-library — the same vocabulary the
+ * Designer / AI-Builder uses for filtering ("show me background-jobs
+ * examples").
+ */
+function collectTags(patterns) {
+    const tags = new Set();
+    for (const p of patterns) {
+        const schema = PATTERN_LIBRARY[p.kind];
+        if (schema)
+            tags.add(schema.category);
+    }
+    return [...tags].sort();
+}
+function countPatternsByKind(patterns) {
+    const counts = {};
+    for (const p of patterns) {
+        counts[p.kind] = (counts[p.kind] ?? 0) + 1;
+    }
+    return counts;
+}

package/dist/framework-version.d.ts

@@ -0,0 +1 @@
+export declare function resolveFrameworkVersion(startDir?: string): string | undefined;

package/dist/framework-version.js

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parseJsonSafe } from "@cosmicdrift/kumiko-framework/utils";
+const DEV_SERVER_PACKAGE = "@cosmicdrift/kumiko-dev-server";
+function isDevServerManifest(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "name" in value &&
+        value.name === DEV_SERVER_PACKAGE &&
+        "version" in value &&
+        typeof value.version === "string" &&
+        value.version !== "");
+}
+// All @cosmicdrift packages release in lockstep (changesets fixed-group), so
+// the dev-server's own version is the framework version.
+export function resolveFrameworkVersion(startDir = import.meta.dir) {
+    let dir = startDir;
+    while (true) {
+        const candidate = join(dir, "package.json");
+        if (existsSync(candidate)) {
+            // A corrupt or foreign package.json on the way up must not abort the search.
+            const manifest = parseJsonSafe(readFileSync(candidate, "utf-8"), undefined);
+            if (isDevServerManifest(manifest))
+                return `^${manifest.version}`;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { type ComposeFeaturesOptions, composeFeatures, } from "@cosmicdrift/kumiko-server-runtime/compose-features";
+export { type CodegenOptions, type CodegenResult, runCodegen, type ScannedEvent, type ScanWarning, scanEvents, } from "./codegen/index.js";
+export { composeFileStack, composeGdprStack, composeIdentityStack, composeMailStack, composeOpsStack, composePagesStack, composeRendererStack, composeUserDataRightsStack, type FileProviderKind, type FileStackOptions, type GdprStackOptions, type GdprStackOrder, type IdentityStackOptions, type MailStackOptions, type MailTransportKind, type OpsStackOptions, type PagesStackOptions, stackFeatureNames, type UserDataRightsStackOptions, } from "./compose-stacks.js";
+export { type CreateKumikoServerOptions, createKumikoServer, type KumikoServerHandle, PROD_BUNDLES_ENV, resolveStylesheet, STYLESHEET_WATCH_ENV, } from "./create-kumiko-server.js";
+export { type FrameworkCoreEnv, frameworkCoreEnvSchema } from "./env-schema.js";
+export type { AuthoringStyle, BuildFewShotCorpusOptions, CorpusWarning, FewShotCorpus, FewShotEntry, } from "./few-shot-corpus.js";
+export { buildFewShotCorpus, pathToId } from "./few-shot-corpus.js";
+export { resolveFrameworkVersion } from "./framework-version.js";
+export type { CliOutput, RunInitDeployCliOptions } from "./init-deploy-cli.js";
+export { runInitDeployCli } from "./init-deploy-cli.js";
+export type { RunDevAppAuthOptions, RunDevAppOptions, SeedFn } from "./run-dev-app.js";
+export { runDevApp } from "./run-dev-app.js";
+export type { ScaffoldAppOptions, ScaffoldAppResult, ScaffoldFeatureEntry, } from "./scaffold-app.js";
+export { scaffoldApp } from "./scaffold-app.js";
+export type { ScaffoldAppFeatureOptions, ScaffoldAppFeatureResult, } from "./scaffold-app-feature.js";
+export { runConfigPathForApp, scaffoldAppFeature } from "./scaffold-app-feature.js";
+export type { CheckDeployDriftResult, DeployDriftEntry, RenderDeployFilesOptions, RenderDeployFilesResult, RenderedDeployFile, ScaffoldDeployDetected, ScaffoldDeployOptions, ScaffoldDeployResult, ScaffoldedFile, } from "./scaffold-deploy.js";
+export { checkDeployDrift, renderDeployFiles, scaffoldDeploy } from "./scaffold-deploy.js";
+export type { ScaffoldFeatureOptions, ScaffoldFeatureResult } from "./scaffold-feature.js";
+export { scaffoldFeature } from "./scaffold-feature.js";
+export { type SetupTestStackFromFeaturesOptions, setupTestStackFromFeatures, type TestStackPreset, } from "./setup-test-stack-from-features.js";
+export { renderWelcomeBanner, type WelcomeBannerInput } from "./welcome-banner.js";

package/dist/index.js

@@ -0,0 +1,33 @@
+// Public API für den Kumiko-Dev-Server. Zwei Schichten:
+//
+//   - createKumikoServer (low-level)
+//     Bun.serve-Wrapper der Client-Bundle, /styles.css, AppSchema-
+//     Injection, SSE-Reload und einen Auto-Mint-JWT-Modus liefert. Nimmt
+//     features + clientEntry direkt an, kein Auth-Auto-Wiring. Wer
+//     einen ungewöhnlichen Auth-Setup braucht (alternative Membership-
+//     Query, eigener Rate-Limiter, custom Login-Routes) geht hier rein.
+//
+//   - runDevApp (high-level)
+//     Mischt die Standard-Features (config/user/tenant/auth-email-
+//     password) automatisch dazu wenn `auth` gesetzt ist, wired die
+//     Login-Routes + Error-Map, ruft seedAdminGuarded im onAfterSetup. Default
+//     für Sample-Apps und Showcases — 5-10 Zeilen Bootstrap statt 50.
+export { composeFeatures, } from "@cosmicdrift/kumiko-server-runtime/compose-features";
+// Build-Toolchain (buildProdBundle, Bun.build, Tailwind-Pipeline, ts-morph) lebt
+// im Sub-Path-Export `@cosmicdrift/kumiko-dev-server/build`. Damit zieht der Main-Barrel
+// kein Bun-Toolchain-Bundle mehr in Production-Reads (z.B. wenn drizzle-kit
+// die App-Config unter Node lädt).
+export { runCodegen, scanEvents, } from "./codegen/index.js";
+export { composeFileStack, composeGdprStack, composeIdentityStack, composeMailStack, composeOpsStack, composePagesStack, composeRendererStack, composeUserDataRightsStack, stackFeatureNames, } from "./compose-stacks.js";
+export { createKumikoServer, PROD_BUNDLES_ENV, resolveStylesheet, STYLESHEET_WATCH_ENV, } from "./create-kumiko-server.js";
+export { frameworkCoreEnvSchema } from "./env-schema.js";
+export { buildFewShotCorpus, pathToId } from "./few-shot-corpus.js";
+export { resolveFrameworkVersion } from "./framework-version.js";
+export { runInitDeployCli } from "./init-deploy-cli.js";
+export { runDevApp } from "./run-dev-app.js";
+export { scaffoldApp } from "./scaffold-app.js";
+export { runConfigPathForApp, scaffoldAppFeature } from "./scaffold-app-feature.js";
+export { checkDeployDrift, renderDeployFiles, scaffoldDeploy } from "./scaffold-deploy.js";
+export { scaffoldFeature } from "./scaffold-feature.js";
+export { setupTestStackFromFeatures, } from "./setup-test-stack-from-features.js";
+export { renderWelcomeBanner } from "./welcome-banner.js";

package/dist/init-deploy-cli.d.ts

@@ -0,0 +1,10 @@
+export type CliOutput = {
+    readonly log: (msg: string) => void;
+    readonly err: (msg: string) => void;
+};
+export type RunInitDeployCliOptions = {
+    readonly argv: readonly string[];
+    readonly cwd: string;
+    readonly out: CliOutput;
+};
+export declare function runInitDeployCli({ argv, cwd, out, }: RunInitDeployCliOptions): Promise<number>;

package/dist/init-deploy-cli.js

@@ -0,0 +1,111 @@
+// `kumiko-init-deploy` CLI — the shared implementation behind both the
+// standalone `kumiko-init-deploy` bin (published, app-facing) and the
+// monorepo's `bin/commands/init-deploy.ts` (delegates here, no duplicated
+// logic).
+import { existsSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { getFlag, getNumberFlag, getStringFlag, parseArgs, } from "@cosmicdrift/kumiko-framework/arg-parser";
+import * as z from "zod";
+import { checkDeployDrift, scaffoldDeploy } from "./scaffold-deploy.js";
+const USAGE = "Usage: kumiko-init-deploy --app <name> [--port <n>] [--github-org <org>] [--out <dir>] [--force | --check]";
+const packageNameSchema = z.object({ name: z.string().optional() });
+/** package.json `name` without its `@scope/` prefix, if present and valid. */
+function defaultAppName(cwd) {
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath))
+        return undefined;
+    try {
+        const pkg = packageNameSchema.parse(JSON.parse(readFileSync(pkgPath, "utf-8")));
+        if (!pkg.name)
+            return undefined;
+        const slash = pkg.name.indexOf("/");
+        return pkg.name.startsWith("@") && slash !== -1 ? pkg.name.slice(slash + 1) : pkg.name;
+    }
+    catch {
+        return undefined;
+    }
+}
+function targetOptions({ appName, port, githubOrg, destination }) {
+    return {
+        appName,
+        ...(port !== undefined && { port }),
+        ...(githubOrg !== undefined && { githubOrg }),
+        destination,
+    };
+}
+function reportDrift(target, out) {
+    const result = checkDeployDrift(targetOptions(target));
+    if (result.drifted.length === 0) {
+        out.log("  ✓ deploy/ is in sync with the current templates.");
+        return 0;
+    }
+    out.err("");
+    out.err(`  ✗ ${result.drifted.length} drifted file(s):`);
+    for (const d of result.drifted) {
+        out.err(`    ${relative(target.destination, d.path)} — ${d.reason}`);
+    }
+    out.err("");
+    out.err("  run kumiko-init-deploy --force to regenerate.");
+    out.err("");
+    return 1;
+}
+function fileMarker(file) {
+    if (!file.written)
+        return "SKIPPED    ";
+    return file.reason === "force" ? "OVERWRITTEN" : "WRITTEN    ";
+}
+function reportScaffold(target, force, out) {
+    const result = scaffoldDeploy({ ...targetOptions(target), force });
+    out.log("");
+    out.log(`  ✓ Deploy scaffolding generated — ${target.appName}`);
+    for (const f of result.files) {
+        out.log(`    ${fileMarker(f)} ${relative(target.destination, f.path)}`);
+    }
+    if (result.files.some((f) => !f.written)) {
+        out.log("");
+        out.log("  Some files were skipped because they already exist. Re-run with --force to overwrite.");
+    }
+    out.log("");
+    out.log("  Next steps:");
+    out.log("    1. Review deploy/Dockerfile — adjust if your app needs extra COPY/ENV steps.");
+    out.log("    2. Wire your image-build workflow to build deploy/Dockerfile and push it.");
+    out.log("    3. Configure the runtime env-vars for your platform.");
+    out.log("");
+    return 0;
+}
+export async function runInitDeployCli({ argv, cwd, out, }) {
+    const args = parseArgs(argv);
+    const force = getFlag(args, "force");
+    const check = getFlag(args, "check");
+    if (force && check) {
+        out.err("");
+        out.err("  --check and --force are mutually exclusive.");
+        out.err(`  ${USAGE}`);
+        out.err("");
+        return 2;
+    }
+    const appName = getStringFlag(args, "app") ?? defaultAppName(cwd);
+    if (!appName) {
+        out.err("");
+        out.err('  --app <name> is required (no package.json "name" found to default from).');
+        out.err(`  ${USAGE}`);
+        out.err("");
+        return 1;
+    }
+    const target = {
+        appName,
+        port: getNumberFlag(args, "port"),
+        githubOrg: getStringFlag(args, "github-org"),
+        destination: getStringFlag(args, "out") ?? cwd,
+    };
+    try {
+        return check ? reportDrift(target, out) : reportScaffold(target, force, out);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        out.err("");
+        out.err(`  ${msg}`);
+        out.err("");
+        return 1;
+    }
+}

package/dist/kebab.d.ts

@@ -0,0 +1 @@
+export declare function isKebabSegment(value: string): boolean;

package/{src/kebab.ts → dist/kebab.js}

@@ -1,8 +1,7 @@
 // Segment-strict: rejects trailing/double hyphen so the name is a valid
 // package-name + folder (`my-shop`, not `my-` or `my--shop`).
 const KEBAB_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
-
 // @wrapper-known semantic-alias
-export function isKebabSegment(value: string): boolean {
-  return KEBAB_RE.test(value);
+export function isKebabSegment(value) {
+    return KEBAB_RE.test(value);
 }