@runa-ai/runa-cli 0.5.26

package/dist/commands/build/contract.d.ts

@@ -0,0 +1,213 @@
+/**
+ * AI HINT: Build Command Contract
+ *
+ * Purpose: Zod schemas for build command I/O validation
+ * Pattern: Contract-first design - all inputs/outputs strictly typed
+ *
+ * Workflow (like vercel build / next build):
+ * 0. Auto-Setup: Install deps, check env, start Supabase (smart detection)
+ * 1. Pre-clean (optional): Clean .next, .turbo, .runa/manifests
+ * 2. Fresh (optional): Delete node_modules + reinstall
+ * 3. Static Analysis: type-check + lint (parallel)
+ * 4. Build: turbo build
+ * 5. DB Sync: runa db sync (if database configured)
+ * 6. Manifest: turbo manifest:generate
+ * 7. Validate: Verify outputs exist
+ */
+import { z } from 'zod';
+/**
+ * Available build phases for partial build (--only option).
+ */
+export declare const BuildPhaseSchema: z.ZodEnum<{
+    lint: "lint";
+    types: "types";
+    build: "build";
+    db: "db";
+    manifest: "manifest";
+}>;
+export type BuildPhase = z.infer<typeof BuildPhaseSchema>;
+/** Valid build phases for --only option */
+export declare const VALID_BUILD_PHASES: BuildPhase[];
+/**
+ * CLI input for build command.
+ */
+export declare const BuildInputSchema: z.ZodObject<{
+    e2e: z.ZodDefault<z.ZodBoolean>;
+    clean: z.ZodDefault<z.ZodBoolean>;
+    fresh: z.ZodDefault<z.ZodBoolean>;
+    skipDb: z.ZodDefault<z.ZodBoolean>;
+    skipManifest: z.ZodDefault<z.ZodBoolean>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    check: z.ZodDefault<z.ZodBoolean>;
+    noSetup: z.ZodDefault<z.ZodBoolean>;
+    targetDir: z.ZodOptional<z.ZodString>;
+    only: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        lint: "lint";
+        types: "types";
+        build: "build";
+        db: "db";
+        manifest: "manifest";
+    }>>>;
+}, z.core.$strict>;
+export type BuildInput = z.infer<typeof BuildInputSchema>;
+/**
+ * Status of a build phase.
+ */
+export declare const BuildPhaseStatusSchema: z.ZodEnum<{
+    passed: "passed";
+    failed: "failed";
+    pending: "pending";
+    running: "running";
+    skipped: "skipped";
+}>;
+export type BuildPhaseStatus = z.infer<typeof BuildPhaseStatusSchema>;
+/**
+ * Result of a build phase.
+ */
+export declare const BuildPhaseResultSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        pending: "pending";
+        running: "running";
+        skipped: "skipped";
+    }>;
+    durationMs: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BuildPhaseResult = z.infer<typeof BuildPhaseResultSchema>;
+/**
+ * Build command output.
+ */
+export declare const BuildOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    exitCode: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    phases: z.ZodObject<{
+        depsInstall: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        envCheck: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        supabaseStart: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        clean: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        fresh: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        typeCheck: z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        lint: z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        build: z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        dbSync: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        manifest: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        validate: z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            durationMs: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    durationMs: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type BuildOutput = z.infer<typeof BuildOutputSchema>;
+//# sourceMappingURL=contract.d.ts.map

package/dist/commands/build/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/commands/build/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;EAAuD,CAAC;AACrF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,2CAA2C;AAC3C,eAAO,MAAM,kBAAkB,EAAE,UAAU,EAAiD,CAAC;AAM7F;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;kBAuBlB,CAAC;AAEZ,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAM1D;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;EAAgE,CAAC;AAEpG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAIjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8BnB,CAAC;AAEZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/commands/build/guards.d.ts

@@ -0,0 +1,106 @@
+/**
+ * AI HINT: Build Command Guards
+ *
+ * Purpose: Guard functions for conditional state transitions
+ * Pattern: Centralized guard logic for XState machine
+ *
+ * Guards determine:
+ * - Whether to run setup phase (deps install, env check, supabase start)
+ * - Whether to run clean/fresh phases
+ * - Whether to skip db sync (no database configured or --skip-db)
+ * - Whether to skip manifest (no task or --skip-manifest)
+ * - Whether in E2E mode
+ */
+import type { BuildContext } from './types.js';
+interface GuardParams {
+    context: BuildContext;
+}
+/**
+ * Check if clean phase should run.
+ * Runs when --clean or --fresh is specified.
+ */
+export declare function shouldClean({ context }: GuardParams): boolean;
+/**
+ * Check if fresh phase should run.
+ * Runs when --fresh is specified.
+ */
+export declare function shouldFresh({ context }: GuardParams): boolean;
+/**
+ * Check if type-check should be skipped.
+ * Skipped when --only is specified and doesn't include 'types'.
+ */
+export declare function shouldSkipTypes({ context }: GuardParams): boolean;
+/**
+ * Check if lint should be skipped.
+ * Skipped when --only is specified and doesn't include 'lint'.
+ */
+export declare function shouldSkipLint({ context }: GuardParams): boolean;
+/**
+ * Check if turbo build should be skipped.
+ * Skipped when --only is specified and doesn't include 'build'.
+ */
+export declare function shouldSkipBuild({ context }: GuardParams): boolean;
+/**
+ * Check if static analysis (type-check + lint) should be skipped entirely.
+ * Skipped when --only is specified and doesn't include 'types' or 'lint'.
+ */
+export declare function shouldSkipStaticAnalysis({ context }: GuardParams): boolean;
+/**
+ * Check if db sync should be skipped.
+ * Skipped when --skip-db, no database configured, or --only doesn't include 'db'.
+ */
+export declare function shouldSkipDb({ context }: GuardParams): boolean;
+/**
+ * Check if manifest generation should be skipped.
+ * Skipped when --skip-manifest, no manifest task, or --only doesn't include 'manifest'.
+ */
+export declare function shouldSkipManifest({ context }: GuardParams): boolean;
+/**
+ * Check if in dry-run mode.
+ */
+export declare function isDryRun({ context }: GuardParams): boolean;
+/**
+ * Check if setup phase should be skipped.
+ * Skipped when --no-setup is specified.
+ */
+export declare function shouldSkipSetup({ context }: GuardParams): boolean;
+/**
+ * Check if in E2E mode.
+ */
+export declare function isE2EMode({ context }: GuardParams): boolean;
+/**
+ * Detect if database is configured.
+ * Checks runa.config.ts for database configuration.
+ */
+export declare function detectDatabase(repoRoot: string): boolean;
+/**
+ * Detect if manifest generation should be enabled.
+ *
+ * Bundler-independent approach (CLI-based, works with Turbopack + Webpack):
+ * - Checks for XState dependencies in package.json
+ * - Checks for runa-xstate-test-plugin dependency
+ * - Checks for runa.config.ts (indicates runa project)
+ *
+ * Note: Uses `runa manifest` CLI command, which is always available
+ * and doesn't depend on webpack plugins or turbo tasks.
+ */
+export declare function detectManifestTask(repoRoot: string): boolean;
+/**
+ * Detect if turbo.json exists.
+ */
+export declare function detectTurbo(repoRoot: string): boolean;
+export declare const guards: {
+    shouldClean: typeof shouldClean;
+    shouldFresh: typeof shouldFresh;
+    shouldSkipTypes: typeof shouldSkipTypes;
+    shouldSkipLint: typeof shouldSkipLint;
+    shouldSkipBuild: typeof shouldSkipBuild;
+    shouldSkipStaticAnalysis: typeof shouldSkipStaticAnalysis;
+    shouldSkipDb: typeof shouldSkipDb;
+    shouldSkipManifest: typeof shouldSkipManifest;
+    shouldSkipSetup: typeof shouldSkipSetup;
+    isDryRun: typeof isDryRun;
+    isE2EMode: typeof isE2EMode;
+};
+export {};
+//# sourceMappingURL=guards.d.ts.map

package/dist/commands/build/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../src/commands/build/guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAM/C,UAAU,WAAW;IACnB,OAAO,EAAE,YAAY,CAAC;CACvB;AAMD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAE7D;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAE7D;AAqBD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAEjE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAEhE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAEjE;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAE1E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAE9D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAMpE;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAE1D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAEjE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAE3D;AAMD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAwBxD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAuB5D;AA4BD;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGrD;AAMD,eAAO,MAAM,MAAM;;;;;;;;;;;;CAYlB,CAAC"}

package/dist/commands/build/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AI HINT: Build Command Barrel Export
+ *
+ * Purpose: Export build command for CLI registration
+ */
+export { buildCommand } from './commands/build.js';
+export { BuildInputSchema, BuildOutputSchema } from './contract.js';
+export type { BuildContext, BuildInput, BuildOutput } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/build/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEpE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/commands/build/machine.d.ts

@@ -0,0 +1,212 @@
+/**
+ * AI HINT: Build State Machine (like vercel build / next build)
+ *
+ * Purpose: Orchestrate build workflow with XState v5
+ * Pattern: Smart self-healing build with auto-detection
+ *
+ * User Journey:
+ * 0. Auto-Setup: Install deps, check env, start Supabase (smart detection)
+ * 1. (Optional) Clean build caches (--clean)
+ * 2. (Optional) Fresh install (--fresh)
+ * 3. Static analysis: type-check + lint (parallel)
+ * 4. Build: turbo build
+ * 5. (Conditional) DB sync: runa db sync
+ * 6. (Conditional) Manifest generation
+ * 7. Validate outputs
+ *
+ * State Flow:
+ * idle → START → [setup] → [clean?] → [fresh?] → staticAnalysis
+ *   → build → [hasDatabase?] → dbSync → [hasManifest?] → manifest
+ *   → validate → done
+ * Any error in blocking phase → failed
+ *
+ * E2E Test Mapping (CLI observable behavior):
+ * - idle → expect(state).toBe('idle')
+ * - setup → expect(log).toContain('Auto-Setup')
+ * - staticAnalysis → expect(log).toContain('type-check')
+ * - build → expect(log).toContain('build')
+ * - done → expect(exitCode).toBe(0)
+ * - failed → expect(exitCode).toBe(1)
+ */
+import { type SnapshotFrom } from 'xstate';
+import type { BuildContext, BuildEvent, BuildInput } from './types.js';
+export declare const buildMachine: import("xstate").StateMachine<BuildContext, BuildEvent, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/build.js").BuildOutput, import("./actors/build.js").BuildInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/manifest.js").ManifestOutput, import("./actors/manifest.js").ManifestInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/clean.js").CleanOutput, import("./actors/clean.js").CleanInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/validate.js").ValidateOutput, import("./actors/validate.js").ValidateInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/setup.js").DepsInstallOutput, import("./actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/setup.js").EnvCheckOutput, import("./actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/setup.js").SupabaseStartOutput, import("./actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/db-sync.js").DbSyncOutput, import("./actors/db-sync.js").DbSyncInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/static-checks.js").StaticChecksOutput, import("./actors/static-checks.js").StaticChecksInput, import("xstate").EventObject>> | undefined;
+}, {
+    src: "build";
+    logic: import("xstate").PromiseActorLogic<import("./actors/build.js").BuildOutput, import("./actors/build.js").BuildInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "manifest";
+    logic: import("xstate").PromiseActorLogic<import("./actors/manifest.js").ManifestOutput, import("./actors/manifest.js").ManifestInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "clean";
+    logic: import("xstate").PromiseActorLogic<import("./actors/clean.js").CleanOutput, import("./actors/clean.js").CleanInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "fresh";
+    logic: import("xstate").PromiseActorLogic<import("./actors/clean.js").CleanOutput, import("./actors/clean.js").CleanInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "validate";
+    logic: import("xstate").PromiseActorLogic<import("./actors/validate.js").ValidateOutput, import("./actors/validate.js").ValidateInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "depsInstall";
+    logic: import("xstate").PromiseActorLogic<import("./actors/setup.js").DepsInstallOutput, import("./actors/setup.js").SetupInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "envCheck";
+    logic: import("xstate").PromiseActorLogic<import("./actors/setup.js").EnvCheckOutput, import("./actors/setup.js").SetupInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "supabaseStart";
+    logic: import("xstate").PromiseActorLogic<import("./actors/setup.js").SupabaseStartOutput, import("./actors/setup.js").SetupInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "dbSync";
+    logic: import("xstate").PromiseActorLogic<import("./actors/db-sync.js").DbSyncOutput, import("./actors/db-sync.js").DbSyncInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "staticChecks";
+    logic: import("xstate").PromiseActorLogic<import("./actors/static-checks.js").StaticChecksOutput, import("./actors/static-checks.js").StaticChecksInput, import("xstate").EventObject>;
+    id: string | undefined;
+}, never, {
+    type: "shouldClean";
+    params: unknown;
+} | {
+    type: "shouldFresh";
+    params: unknown;
+} | {
+    type: "shouldSkipTypes";
+    params: unknown;
+} | {
+    type: "shouldSkipLint";
+    params: unknown;
+} | {
+    type: "shouldSkipBuild";
+    params: unknown;
+} | {
+    type: "shouldSkipStaticAnalysis";
+    params: unknown;
+} | {
+    type: "shouldSkipDb";
+    params: unknown;
+} | {
+    type: "shouldSkipManifest";
+    params: unknown;
+} | {
+    type: "shouldSkipSetup";
+    params: unknown;
+} | {
+    type: "isDryRun";
+    params: unknown;
+}, never, "failed" | "build" | "manifest" | "clean" | "fresh" | "validate" | "dbSync" | "done" | "preClean" | "dryRun" | "staticAnalysis" | "idle" | {
+    setup: "depsInstall" | "envCheck" | "supabaseStart" | "done";
+}, string, {
+    input: BuildInput;
+    repoRoot: string;
+}, {
+    success: boolean;
+    exitCode: 0 | 1;
+    phases: {
+        typeCheck: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        };
+        lint: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        };
+        build: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        };
+        validate: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        };
+        depsInstall?: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        } | undefined;
+        envCheck?: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        } | undefined;
+        supabaseStart?: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        } | undefined;
+        clean?: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        } | undefined;
+        fresh?: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        } | undefined;
+        dbSync?: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        } | undefined;
+        manifest?: {
+            status: "passed" | "failed" | "pending" | "running" | "skipped";
+            durationMs: number;
+            error?: string | undefined;
+        } | undefined;
+    };
+    durationMs: number;
+    error?: string | undefined;
+    warnings?: string[] | undefined;
+}, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "build";
+    states: {
+        readonly idle: {};
+        readonly dryRun: {};
+        readonly setup: {
+            states: {
+                readonly depsInstall: {};
+                readonly envCheck: {};
+                readonly supabaseStart: {};
+                readonly done: {};
+            };
+        };
+        readonly preClean: {};
+        readonly clean: {};
+        readonly fresh: {};
+        readonly staticAnalysis: {};
+        readonly build: {};
+        readonly dbSync: {};
+        readonly manifest: {};
+        readonly validate: {};
+        readonly done: {};
+        readonly failed: {};
+    };
+}>;
+export type BuildMachine = typeof buildMachine;
+export type BuildSnapshot = SnapshotFrom<typeof buildMachine>;
+/**
+ * Get current state name from snapshot.
+ */
+export declare function getStateName(snapshot: BuildSnapshot): string;
+/**
+ * Check if machine has completed.
+ */
+export declare function isComplete(snapshot: BuildSnapshot): boolean;
+/**
+ * Get error from snapshot context.
+ */
+export declare function getError(snapshot: BuildSnapshot): string | null;
+//# sourceMappingURL=machine.d.ts.map

package/dist/commands/build/machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/commands/build/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAU,KAAK,YAAY,EAAS,MAAM,QAAQ,CAAC;AAe1D,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAe,MAAM,YAAY,CAAC;AAmPpF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIL,UAAU;cAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6nB9C,CAAC;AAMH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC;AAC/C,MAAM,MAAM,aAAa,GAAG,YAAY,CAAC,OAAO,YAAY,CAAC,CAAC;AAM9D;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAa5D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAE3D;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAE/D"}

package/dist/commands/build/types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * AI HINT: Build Command Types
+ *
+ * Purpose: Type definitions for build state machine
+ * Pattern: Re-export from contract.ts (Zod SSOT) + machine-specific types
+ *
+ * Architecture:
+ * - contract.ts: Zod schemas (SSOT) + inferred types
+ * - types.ts: Re-exports + machine-specific types (BuildContext, BuildEvent)
+ */
+import type { BuildInput as _BuildInput, BuildOutput as _BuildOutput, BuildPhaseResult as _BuildPhaseResult, BuildPhaseStatus as _BuildPhaseStatus } from './contract.js';
+export type BuildInput = _BuildInput;
+export type BuildOutput = _BuildOutput;
+export type BuildPhaseResult = _BuildPhaseResult;
+export type BuildPhaseStatus = _BuildPhaseStatus;
+/**
+ * Build machine context.
+ * Contains all state needed across build phases.
+ */
+export interface BuildContext {
+    /** CLI input parameters */
+    input: BuildInput;
+    /** Repository root directory */
+    repoRoot: string;
+    /** Temporary directory for logs */
+    tmpDir: string;
+    /** Whether database is configured (runa.config.ts has database) */
+    hasDatabase: boolean;
+    /** Whether manifest task exists (turbo.json has manifest:generate) */
+    hasManifestTask: boolean;
+    /** Whether turbo.json exists */
+    hasTurbo: boolean;
+    phases: {
+        depsInstall: BuildPhaseResult | null;
+        envCheck: BuildPhaseResult | null;
+        supabaseStart: BuildPhaseResult | null;
+        clean: BuildPhaseResult | null;
+        fresh: BuildPhaseResult | null;
+        typeCheck: BuildPhaseResult | null;
+        lint: BuildPhaseResult | null;
+        build: BuildPhaseResult | null;
+        dbSync: BuildPhaseResult | null;
+        manifest: BuildPhaseResult | null;
+        validate: BuildPhaseResult | null;
+    };
+    /** Start time */
+    startTime: number;
+    /** Fatal error (blocks further execution) */
+    error: string | null;
+    /** Non-fatal warnings */
+    warnings: string[];
+}
+/**
+ * Build machine events.
+ */
+export type BuildEvent = {
+    type: 'START';
+};
+/**
+ * Create initial context from input.
+ */
+export declare function createInitialContext(input: BuildInput, repoRoot: string): BuildContext;
+/**
+ * Create output from context.
+ */
+export declare function createOutput(context: BuildContext): BuildOutput;
+/**
+ * Extract error message from unknown error value.
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Create a phase result.
+ */
+export declare function createPhaseResult(status: BuildPhaseStatus, durationMs: number, error?: string): BuildPhaseResult;
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/commands/build/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,UAAU,IAAI,WAAW,EACzB,WAAW,IAAI,YAAY,EAC3B,gBAAgB,IAAI,iBAAiB,EACrC,gBAAgB,IAAI,iBAAiB,EACtC,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC;AACrC,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC;AACvC,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AACjD,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AAMjD;;;GAGG;AACH,MAAM,WAAW,YAAY;IAE3B,2BAA2B;IAC3B,KAAK,EAAE,UAAU,CAAC;IAGlB,gCAAgC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAC;IAGf,mEAAmE;IACnE,WAAW,EAAE,OAAO,CAAC;IACrB,sEAAsE;IACtE,eAAe,EAAE,OAAO,CAAC;IACzB,gCAAgC;IAChC,QAAQ,EAAE,OAAO,CAAC;IAGlB,MAAM,EAAE;QAEN,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAAC;QACrC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;QAClC,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;QAEvC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;QAC/B,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;QAE/B,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;QACnC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;QAC9B,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;QAC/B,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;QAChC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;QAClC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;KACnC,CAAC;IAGF,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAGlB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,yBAAyB;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAMD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAM3C;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CA4BtF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW,CAiC/D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEtD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,MAAM,EAClB,KAAK,CAAC,EAAE,MAAM,GACb,gBAAgB,CAElB"}

package/dist/commands/cache.d.ts

@@ -0,0 +1,32 @@
+/**
+ * AI HINT: Cache management commands
+ *
+ * Purpose: CLI commands for cache operations
+ * Features: Clear, prune, stats, inspect
+ */
+import { Command } from 'commander';
+/**
+ * Clear cache command
+ */
+export declare const cacheClearCommand: Command;
+/**
+ * Prune cache command
+ */
+export declare const cachePruneCommand: Command;
+/**
+ * Cache stats command
+ */
+export declare const cacheStatsCommand: Command;
+/**
+ * Cache list command
+ */
+export declare const cacheListCommand: Command;
+/**
+ * Cache invalidate command
+ */
+export declare const cacheInvalidateCommand: Command;
+/**
+ * Main cache command
+ */
+export declare const cacheCommand: Command;
+//# sourceMappingURL=cache.d.ts.map

package/dist/commands/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/commands/cache.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAgBH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC;;GAEG;AACH,eAAO,MAAM,iBAAiB,SAsB1B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,iBAAiB,SAsB1B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,iBAAiB,SAqB1B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,gBAAgB,SAkBzB,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB,SAqB/B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,YAAY,SAMY,CAAC"}