@runa-ai/runa-cli 0.5.26

package/dist/commands/db/utils/semantic-mapper.d.ts

@@ -0,0 +1,119 @@
+/**
+ * AI HINT: Semantic Name Mapper
+ *
+ * Purpose: Generate SDK-friendly semantic names from qualified table names
+ *
+ * Mapping Rules:
+ * 1. accounts.clients → clients (table name as-is if unique)
+ * 2. accounts.client_settings → clientSettings (snake_case → camelCase)
+ * 3. Conflict resolution: If multiple schemas have same table name,
+ *    use schema prefix (e.g., accountsClients, reposClients)
+ *
+ * Output:
+ * {
+ *   "clients": "accounts.clients",
+ *   "repositories": "repos.repositories",
+ *   "clientSettings": "accounts.client_settings"
+ * }
+ */
+import type { TableEntry } from '@runa-ai/runa/manifests';
+/**
+ * Convert snake_case to camelCase
+ *
+ * @example
+ * snakeToCamel('test_runs') // 'testRuns'
+ * snakeToCamel('user_profile_settings') // 'userProfileSettings'
+ */
+export declare function snakeToCamel(str: string): string;
+/**
+ * Convert snake_case to PascalCase
+ *
+ * @example
+ * snakeToPascal('test_runs') // 'TestRuns'
+ * snakeToPascal('user_profile') // 'UserProfile'
+ */
+export declare function snakeToPascal(str: string): string;
+/**
+ * Generate semantic name from qualified table name
+ *
+ * @param schema - Schema name (e.g., 'accounts')
+ * @param tableName - Table name (e.g., 'clients')
+ * @param useSchemaPrefix - Whether to prefix with schema name for disambiguation
+ *
+ * @example
+ * generateSemanticName('accounts', 'clients', false) // 'clients'
+ * generateSemanticName('accounts', 'clients', true) // 'accountsClients'
+ */
+export declare function generateSemanticName(schema: string, tableName: string, useSchemaPrefix?: boolean): string;
+export interface MappingOptions {
+    /**
+     * Strategy for handling name conflicts
+     * - 'prefix': Use schema prefix (e.g., accountsClients)
+     * - 'error': Throw error on conflict
+     * - 'first': Use first occurrence only
+     */
+    conflictStrategy?: 'prefix' | 'error' | 'first';
+    /**
+     * Schemas to prioritize when using 'first' strategy
+     * Tables from these schemas get simple names first
+     */
+    prioritySchemas?: string[];
+    /**
+     * Custom name overrides
+     * {
+     *   'accounts.clients': 'customers',
+     *   'repos.repositories': 'repos'
+     * }
+     */
+    overrides?: Record<string, string>;
+}
+export interface MappingResult {
+    /** Semantic name → qualified name mapping */
+    mapping: Record<string, string>;
+    /** Detected conflicts (before resolution) */
+    conflicts: Array<{
+        semanticName: string;
+        tables: string[];
+    }>;
+    /** Tables that couldn't be mapped (with 'first' strategy) */
+    skipped: string[];
+}
+/**
+ * Generate semantic name mapping from table entries
+ *
+ * @param tables - Table entries from SQL extraction
+ * @param options - Mapping options
+ * @returns Mapping result with conflicts and skipped tables
+ *
+ * @example
+ * ```typescript
+ * const tables = extractTablesFromSqlDir('supabase/schemas/declarative');
+ * const result = generateMapping(tables, { conflictStrategy: 'prefix' });
+ * console.log(result.mapping);
+ * // { clients: 'accounts.clients', repositories: 'repos.repositories' }
+ * ```
+ */
+export declare function generateMapping(tables: TableEntry[], options?: MappingOptions): MappingResult;
+/**
+ * Update table entries with semantic names based on mapping
+ *
+ * @param tables - Table entries to update
+ * @param mapping - Semantic name mapping
+ * @returns Updated table entries with semanticName field
+ */
+export declare function applyMappingToTables(tables: TableEntry[], mapping: Record<string, string>): TableEntry[];
+/**
+ * Validate that mapping has no duplicate semantic names
+ */
+export declare function validateMapping(mapping: Record<string, string>): {
+    valid: boolean;
+    duplicates: string[];
+};
+/**
+ * Validate that all tables are mapped
+ */
+export declare function validateCompleteness(tables: TableEntry[], mapping: Record<string, string>): {
+    valid: boolean;
+    unmapped: string[];
+};
+//# sourceMappingURL=semantic-mapper.d.ts.map

package/dist/commands/db/utils/semantic-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-mapper.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/semantic-mapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAM1D;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGjD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,eAAe,UAAQ,GACtB,MAAM,CAUR;AAMD,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;IAEhD;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAE3B;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,aAAa;IAC5B,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC,6CAA6C;IAC7C,SAAS,EAAE,KAAK,CAAC;QACf,YAAY,EAAE,MAAM,CAAC;QACrB,MAAM,EAAE,MAAM,EAAE,CAAC;KAClB,CAAC,CAAC;IAEH,6DAA6D;IAC7D,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,OAAO,GAAE,cAAmB,GAAG,aAAa,CAmFjG;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,UAAU,EAAE,CAWd;AAMD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;IAChE,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAeA;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B;IACD,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAcA"}

package/dist/commands/db/utils/sql-table-extractor.d.ts

@@ -0,0 +1,56 @@
+/**
+ * AI HINT: Enhanced SQL Table Extractor
+ *
+ * Purpose: Extract table definitions with metadata from SQL files
+ * Pattern: AST-based parsing (libpg-query) with regex fallback
+ *
+ * Extracts:
+ * - Table definitions (schema.table)
+ * - Column definitions (name, type, constraints)
+ * - Primary keys (PRIMARY KEY)
+ * - Foreign keys (REFERENCES)
+ * - Indexes (CREATE INDEX)
+ * - RLS policies (CREATE POLICY)
+ * - Source file and line numbers
+ *
+ * Architecture:
+ * - Primary: libpg-query AST parsing (accurate, handles edge cases)
+ * - Fallback: Regex parsing (for pj-repos without libpg-query)
+ *
+ * Note: This is a lightweight parser for manifest generation.
+ * For full SQL parsing, use pg_catalog queries (see introspectColumns).
+ */
+import type { TableEntry } from '@runa-ai/runa/manifests';
+export interface ExtractOptions {
+    /** Include column definitions */
+    includeColumns?: boolean;
+    /** Include foreign keys */
+    includeForeignKeys?: boolean;
+    /** Include indexes */
+    includeIndexes?: boolean;
+    /** Include RLS policies */
+    includeRlsPolicies?: boolean;
+}
+/**
+ * Extract table definitions from SQL files
+ *
+ * Uses libpg-query AST parsing when available, falls back to regex parsing.
+ *
+ * @param sqlDir - Directory containing SQL files
+ * @param options - Extraction options
+ * @returns Array of table entries
+ *
+ * @example
+ * ```typescript
+ * const tables = await extractTablesFromSqlDir('supabase/schemas/declarative');
+ * console.log(tables[0].qualifiedName); // 'accounts.clients'
+ * ```
+ */
+export declare function extractTablesFromSqlDir(sqlDir: string, options?: ExtractOptions): Promise<TableEntry[]>;
+/**
+ * Extract tables from a single SQL file
+ *
+ * Uses libpg-query AST parsing when available, falls back to regex parsing.
+ */
+export declare function extractTablesFromSqlFile(filePath: string, options?: ExtractOptions): Promise<TableEntry[]>;
+//# sourceMappingURL=sql-table-extractor.d.ts.map

package/dist/commands/db/utils/sql-table-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-table-extractor.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/sql-table-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,KAAK,EAKV,UAAU,EACX,MAAM,yBAAyB,CAAC;AAghBjC,MAAM,WAAW,cAAc;IAC7B,iCAAiC;IACjC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,2BAA2B;IAC3B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,sBAAsB;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,2BAA2B;IAC3B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAyHD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAkBvB;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAKvB"}

package/dist/commands/db/utils/stack-detector.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AI HINT: Database stack detection utility
+ *
+ * Purpose: Automatically detect database stack type (Drizzle vs Supabase SQL)
+ * Design: Dynamic detection via getDatabasePackagePath() (no hardcoding)
+ */
+export type DatabaseStack = 'drizzle' | 'supabase';
+export interface StackDetectionResult {
+    stack: DatabaseStack;
+    confidence: 'high' | 'medium' | 'low';
+    reason: string;
+    paths: {
+        drizzleConfig?: string;
+        supabaseSchemas?: string;
+    };
+}
+/**
+ * Detect database stack type
+ *
+ * Detection logic:
+ * 1. Try getDatabasePackagePath() + drizzle.config.ts → Drizzle (high confidence)
+ * 2. Check for supabase/schemas/ → Supabase SQL (high confidence)
+ * 3. Fallback to runa.config.ts database.type
+ */
+export declare function detectDatabaseStack(cwd?: string): Promise<StackDetectionResult>;
+/**
+ * Get stack-specific paths (dynamic, no hardcoding)
+ */
+export declare function getStackPaths(stack: DatabaseStack, cwd?: string): Promise<{
+    rootDir: string;
+    schemaDir: string;
+    configFile: string;
+}>;
+//# sourceMappingURL=stack-detector.d.ts.map

package/dist/commands/db/utils/stack-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-detector.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/stack-detector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,UAAU,CAAC;AAEnD,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE;QACL,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,SAAgB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAqC5F;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,SAAgB;;;;GAqB5E"}

package/dist/commands/db/utils/table-registry.d.ts

@@ -0,0 +1,112 @@
+/**
+ * AI HINT: Table Registry Generator (Manifest-First Architecture)
+ *
+ * Purpose: Generate .runa/manifests/tables.json from database introspection
+ * Pattern: DB Introspection PRIMARY, SQL regex FALLBACK
+ *
+ * Flow:
+ * 1. If databaseUrl provided → DB introspection (PostgreSQL system catalogs, 100% accurate)
+ * 2. SQL regex for sourceFile mapping only (which SQL file defined each table)
+ * 3. If no databaseUrl → SQL regex as fallback
+ * 4. Generate TablesManifest for SDK consumption
+ *
+ * Why DB Introspection is PRIMARY:
+ * - PostgreSQL system catalogs (information_schema, pg_catalog) are the official metadata
+ * - SQL is parsed by PostgreSQL itself, so the catalog data is 100% accurate
+ * - Regex parsing has inherent limitations (nested parentheses, complex syntax)
+ *
+ * Output: .runa/manifests/tables.json (TablesManifest format)
+ *
+ * @see packages/sdk/src/core/manifests/types.ts - TablesManifest type definition
+ * @see packages/sdk/src/test/generator/introspectors/db-introspector.ts - DB introspection
+ * @see packages/cli/src/commands/db/utils/sql-table-extractor.ts - SQL parser (fallback)
+ */
+import type { TableEntry, TablesManifest } from '@runa-ai/runa/manifests';
+import { type MappingOptions } from './semantic-mapper.js';
+/**
+ * Introspect tables from database using PostgreSQL system catalogs
+ *
+ * This is the PRIMARY source for table metadata (when database is available).
+ * PostgreSQL system catalogs are 100% accurate because PostgreSQL itself
+ * parsed and stored the schema information.
+ *
+ * @param databaseUrl - PostgreSQL connection string
+ * @param schemas - Schema names to include (default: auto-detect non-system schemas)
+ * @returns TableEntry[] with accurate metadata from database
+ * @throws Error if database connection or introspection fails
+ */
+export declare function introspectTablesFromDb(databaseUrl: string, schemas?: string[]): Promise<TableEntry[]>;
+/**
+ * Cross-check SQL tables with Drizzle schema
+ *
+ * Uses dynamic import to load Drizzle schema and verify table names match.
+ * Returns discrepancies if any.
+ *
+ * Note: This is for validation only. SQL is the SSOT.
+ */
+export declare function crossCheckWithDrizzle(sqlTables: TableEntry[], drizzleSchemaPath: string): Promise<{
+    matched: TableEntry[];
+    sqlOnly: TableEntry[];
+    drizzleOnly: string[];
+}>;
+/**
+ * Introspect column information from database
+ *
+ * Zero Hardcode: All info from pg_catalog
+ * This enriches SQL-extracted data with runtime database metadata.
+ *
+ * @param databaseUrl - PostgreSQL connection string
+ * @param tables - Tables to introspect
+ * @returns Tables with enriched column information
+ */
+export declare function introspectColumns(databaseUrl: string, tables: TableEntry[]): Promise<TableEntry[]>;
+export interface GenerateManifestOptions {
+    /** SQL directory (default: supabase/schemas/declarative) */
+    sqlDir?: string;
+    /** Drizzle schema path for cross-check (optional) */
+    drizzleSchemaPath?: string;
+    /** Output path (default: .runa/manifests/tables.json) */
+    outputPath?: string;
+    /** Whether to cross-check with Drizzle (for validation) */
+    crossCheck?: boolean;
+    /** Database URL for column enrichment (optional) */
+    databaseUrl?: string;
+    /** Semantic name mapping options */
+    mappingOptions?: MappingOptions;
+    /** Include detailed metadata (columns, FKs, indexes, RLS) */
+    includeMetadata?: boolean;
+}
+/**
+ * Generate TablesManifest using DB introspection (PRIMARY) or SQL regex (FALLBACK)
+ *
+ * Architecture:
+ * - PRIMARY: Database introspection via PostgreSQL system catalogs (100% accurate)
+ * - FALLBACK: SQL regex parsing (when database is not available)
+ * - SQL files always used for: sourceFile mapping (which file defined each table)
+ *
+ * @param projectRoot - Project root directory
+ * @param options - Generation options
+ * @returns Generated TablesManifest
+ *
+ * @example
+ * ```typescript
+ * const manifest = await generateTablesManifest('/path/to/project', {
+ *   databaseUrl: process.env.DATABASE_URL,
+ *   includeMetadata: true,
+ * });
+ * console.log(manifest.mapping);
+ * // { clients: 'accounts.clients', repositories: 'repos.repositories', ... }
+ * ```
+ */
+export declare function generateTablesManifest(projectRoot: string, options?: GenerateManifestOptions): Promise<TablesManifest>;
+/**
+ * Load full TablesManifest from .runa/manifests/tables.json
+ *
+ * @param projectRoot - Project root directory
+ * @returns Full manifest or null if not found
+ */
+export declare function loadTablesManifest(projectRoot: string): TablesManifest | null;
+export type { TableEntry, TablesManifest } from '@runa-ai/runa/manifests';
+export { applyMappingToTables, generateMapping, generateSemanticName, type MappingOptions, type MappingResult, snakeToCamel, snakeToPascal, validateCompleteness, validateMapping, } from './semantic-mapper.js';
+export { extractTablesFromSqlDir, extractTablesFromSqlFile } from './sql-table-extractor.js';
+//# sourceMappingURL=table-registry.d.ts.map

package/dist/commands/db/utils/table-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-registry.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/table-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,KAAK,EAMV,UAAU,EACV,cAAc,EAEf,MAAM,yBAAyB,CAAC;AAIjC,OAAO,EAAyC,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAiBlG;;;;;;;;;;;GAWG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,UAAU,EAAE,CAAC,CAmDvB;AA4PD;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,UAAU,EAAE,EACvB,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAAC;IACT,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC,CAYD;AAMD;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,UAAU,EAAE,GACnB,OAAO,CAAC,UAAU,EAAE,CAAC,CA0HvB;AAMD,MAAM,WAAW,uBAAuB;IACtC,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oDAAoD;IACpD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oCAAoC;IACpC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,6DAA6D;IAC7D,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAuCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,cAAc,CAAC,CA6GzB;AA+FD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAa7E;AAMD,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/commands/dev/actors/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AI HINT: Dev Command Actors
+ *
+ * Purpose: Re-export actors from build and ci commands
+ * Pattern: Actor reuse for dev workflow
+ *
+ * Actors:
+ * - depsInstallActor: Check/install dependencies
+ * - envCheckActor: Check environment variables
+ * - supabaseStartActor: Start Supabase local
+ * - appStartActor: Start Next.js dev server
+ */
+export { depsInstallActor, envCheckActor, supabaseStartActor, } from '../../build/actors/setup.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/dev/actors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/dev/actors/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,kBAAkB,GACnB,MAAM,6BAA6B,CAAC"}

package/dist/commands/dev/commands/dev.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AI HINT: `runa dev` - Dev Command Entry Point
+ *
+ * Purpose: Unified development server with Supabase integration
+ * Pattern: Start Supabase + Next.js dev server with graceful shutdown
+ *
+ * Usage:
+ * - runa dev                    # Start Supabase + app on port 3000
+ * - runa dev --port 3001        # Custom port
+ * - runa dev --skip-db          # Skip Supabase start
+ * - runa dev --skip-app         # Supabase only (no app server)
+ */
+import { Command } from 'commander';
+export declare const devCommand: Command;
+//# sourceMappingURL=dev.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../src/commands/dev/commands/dev.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuMpC,eAAO,MAAM,UAAU,SAiBnB,CAAC"}

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

@@ -0,0 +1,46 @@
+/**
+ * AI HINT: Dev Command Contract
+ *
+ * Purpose: Zod schemas for dev command I/O validation
+ * Pattern: Contract-first design - all inputs/outputs strictly typed
+ *
+ * Workflow:
+ * 1. Setup: Install deps, check env, start Supabase (optional)
+ * 2. Start: Launch Next.js dev server
+ * 3. Running: Dev server running until SIGINT/SIGTERM
+ */
+import { z } from 'zod';
+/**
+ * CLI input for dev command.
+ */
+export declare const DevInputSchema: z.ZodObject<{
+    port: z.ZodDefault<z.ZodNumber>;
+    skipDb: z.ZodDefault<z.ZodBoolean>;
+    skipApp: z.ZodDefault<z.ZodBoolean>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    targetDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type DevInput = z.infer<typeof DevInputSchema>;
+/**
+ * Status of a dev phase.
+ */
+export declare const DevPhaseStatusSchema: z.ZodEnum<{
+    passed: "passed";
+    failed: "failed";
+    pending: "pending";
+    running: "running";
+    skipped: "skipped";
+}>;
+export type DevPhaseStatus = z.infer<typeof DevPhaseStatusSchema>;
+/**
+ * Dev command output.
+ */
+export declare const DevOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    exitCode: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    appPid: z.ZodOptional<z.ZodNumber>;
+    supabaseStarted: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type DevOutput = z.infer<typeof DevOutputSchema>;
+//# sourceMappingURL=contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;kBAahB,CAAC;AAEZ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAMtD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;EAAgE,CAAC;AAElG,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAMlE;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;kBAajB,CAAC;AAEZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

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

@@ -0,0 +1,26 @@
+/**
+ * AI HINT: Dev Command Guards
+ *
+ * Purpose: Guard functions for conditional state transitions
+ * Pattern: Centralized guard logic for XState machine
+ */
+import type { DevContext } from './types.js';
+interface GuardParams {
+    context: DevContext;
+}
+/**
+ * Check if Supabase should be skipped.
+ * Skipped when --skip-db or no database configured.
+ */
+export declare function shouldSkipDb({ context }: GuardParams): boolean;
+/**
+ * Check if app should be skipped.
+ * Skipped when --skip-app is specified.
+ */
+export declare function shouldSkipApp({ context }: GuardParams): boolean;
+export declare const guards: {
+    shouldSkipDb: typeof shouldSkipDb;
+    shouldSkipApp: typeof shouldSkipApp;
+};
+export {};
+//# sourceMappingURL=guards.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/guards.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAM7C,UAAU,WAAW;IACnB,OAAO,EAAE,UAAU,CAAC;CACrB;AAMD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAE9D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,OAAO,CAE/D;AAMD,eAAO,MAAM,MAAM;;;CAGlB,CAAC"}

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

@@ -0,0 +1,121 @@
+/**
+ * AI HINT: Dev State Machine
+ *
+ * Purpose: Orchestrate local development environment
+ * Pattern: Simple linear flow with graceful shutdown
+ *
+ * User Journey:
+ * 1. Setup: Check deps, env, start Supabase (optional)
+ * 2. Start: Launch Next.js dev server
+ * 3. Running: Dev server running until SIGINT/SIGTERM
+ *
+ * State Flow:
+ * idle → START → setup{depsInstall → envCheck → supabaseStart}
+ *   → appStart → running → (STOP) → shutdown → done
+ * Any error → failed
+ *
+ * E2E Test Mapping (CLI observable behavior):
+ * - idle → expect(log).toContain('Starting dev')
+ * - setup → expect(log).toContain('Setup')
+ * - appStart → expect(log).toContain('Starting app')
+ * - running → expect(log).toContain('Dev server running')
+ * - shutdown → expect(log).toContain('Shutting down')
+ * - done → expect(exitCode).toBe(0)
+ * - failed → expect(exitCode).toBe(1)
+ */
+import { type SnapshotFrom } from 'xstate';
+import type { DevContext, DevInput } from './types.js';
+interface AppStartInput {
+    repoRoot: string;
+    appDir: string;
+    port: number;
+    tmpDir: string;
+}
+interface AppStartOutput {
+    pid: number;
+    cleanupStreams: () => void;
+}
+interface ShutdownInput {
+    pid: number;
+}
+export declare const devMachine: import("xstate").StateMachine<DevContext, {
+    type: "START";
+} | {
+    type: "STOP";
+} | {
+    type: "error.platform";
+    error: Error;
+}, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").DepsInstallOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").EnvCheckOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").SupabaseStartOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<AppStartOutput, AppStartInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, ShutdownInput, import("xstate").EventObject>> | undefined;
+}, {
+    src: "depsInstall";
+    logic: import("xstate").PromiseActorLogic<import("../build/actors/setup.js").DepsInstallOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "envCheck";
+    logic: import("xstate").PromiseActorLogic<import("../build/actors/setup.js").EnvCheckOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "supabaseStart";
+    logic: import("xstate").PromiseActorLogic<import("../build/actors/setup.js").SupabaseStartOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "appStart";
+    logic: import("xstate").PromiseActorLogic<AppStartOutput, AppStartInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "shutdown";
+    logic: import("xstate").PromiseActorLogic<void, ShutdownInput, import("xstate").EventObject>;
+    id: string | undefined;
+}, never, {
+    type: "shouldSkipDb";
+    params: unknown;
+} | {
+    type: "shouldSkipApp";
+    params: unknown;
+}, never, "failed" | "running" | "done" | "idle" | "appStart" | "shutdown" | {
+    setup: "depsInstall" | "envCheck" | "supabaseStart" | "done";
+}, string, {
+    input: DevInput;
+    repoRoot: string;
+}, {
+    success: boolean;
+    exitCode: 0 | 1;
+    appPid?: number | undefined;
+    supabaseStarted?: boolean | undefined;
+    error?: string | undefined;
+}, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "dev";
+    states: {
+        readonly idle: {};
+        readonly setup: {
+            states: {
+                readonly depsInstall: {};
+                readonly envCheck: {};
+                readonly supabaseStart: {};
+                readonly done: {};
+            };
+        };
+        readonly appStart: {};
+        readonly running: {};
+        readonly shutdown: {};
+        readonly done: {};
+        readonly failed: {};
+    };
+}>;
+export type DevMachine = typeof devMachine;
+export type DevSnapshot = SnapshotFrom<typeof devMachine>;
+/**
+ * Get current state name from snapshot.
+ */
+export declare function getStateName(snapshot: DevSnapshot): string;
+/**
+ * Check if machine has completed.
+ */
+export declare function isComplete(snapshot: DevSnapshot): boolean;
+/**
+ * Get error from snapshot context.
+ */
+export declare function getError(snapshot: DevSnapshot): string | null;
+export {};
+//# sourceMappingURL=machine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAC;AAS1D,OAAO,KAAK,EAAE,UAAU,EAAY,QAAQ,EAAa,MAAM,YAAY,CAAC;AAsF5E,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,cAAc;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAkCD,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;CACb;AAoBD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIH,QAAQ;cAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;EA6K5C,CAAC;AAMH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC;AAC3C,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;AAM1D;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAa1D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAE7D"}

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

@@ -0,0 +1,44 @@
+/**
+ * AI HINT: Dev Command Types
+ *
+ * Purpose: TypeScript types for dev command
+ * Pattern: Re-export from contract.ts (Zod SSOT) + machine context
+ */
+import type { DevInput as _DevInput, DevOutput as _DevOutput, DevPhaseStatus as _DevPhaseStatus } from './contract.js';
+export type DevInput = _DevInput;
+export type DevOutput = _DevOutput;
+export type DevPhaseStatus = _DevPhaseStatus;
+/**
+ * Dev machine context.
+ */
+export interface DevContext {
+    /** Parsed input options */
+    input: DevInput;
+    /** Repository root directory */
+    repoRoot: string;
+    /** Temporary directory for logs */
+    tmpDir: string;
+    /** Whether Supabase is configured */
+    hasDatabase: boolean;
+    /** App process PID (when running) */
+    appPid: number | null;
+    /** Whether Supabase was started */
+    supabaseStarted: boolean;
+    /** Start time for duration tracking */
+    startTime: number;
+    /** Error message if failed */
+    error: string | null;
+}
+export type DevEvent = {
+    type: 'START';
+} | {
+    type: 'STOP';
+} | {
+    type: 'error.platform';
+    error: Error;
+};
+/**
+ * Create dev output from context.
+ */
+export declare function createOutput(context: DevContext): DevOutput;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,QAAQ,IAAI,SAAS,EACrB,SAAS,IAAI,UAAU,EACvB,cAAc,IAAI,eAAe,EAClC,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC;AACjC,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC;AACnC,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC;AAM7C;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,2BAA2B;IAC3B,KAAK,EAAE,QAAQ,CAAC;IAChB,gCAAgC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,WAAW,EAAE,OAAO,CAAC;IACrB,qCAAqC;IACrC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,mCAAmC;IACnC,eAAe,EAAE,OAAO,CAAC;IACzB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAMD,MAAM,MAAM,QAAQ,GAChB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAM7C;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,CAQ3D"}

package/dist/commands/env/commands/env-check.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AI HINT: Environment check command
+ *
+ * Purpose: Verify environment variables are configured correctly
+ * Design: Check local files, Supabase status, and provide guidance for remote checks
+ *
+ * Checks:
+ * 1. Local Development:
+ *    - .env.development exists
+ *    - .env.keys exists (for decryption)
+ *    - Local Supabase running (port 54322)
+ *
+ * 2. Production (guidance only):
+ *    - GitHub Secrets (cannot verify remotely)
+ *    - Vercel env vars (cannot verify remotely)
+ *
+ * Usage:
+ *   runa env check                    # Check all environments
+ *   runa env check --local            # Check local only
+ *   runa env check --verbose          # Show detailed info
+ */
+import { Command } from 'commander';
+export declare const checkCommand: Command;
+//# sourceMappingURL=env-check.d.ts.map