@pikku/cli 0.12.49 → 0.12.51

package/dist/.pikku/variables/pikku-variable-types.gen.js

@@ -1,4 +1,4 @@
 /**
- * This file was generated by @pikku/cli@0.12.49
+ * This file was generated by @pikku/cli@0.12.51
  */
 export { wireVariable } from '@pikku/core/variable';

package/dist/.pikku/variables/pikku-variables.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.49
+ * This file was generated by @pikku/cli@0.12.51
  */
 import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
 import type { VariablesService } from '@pikku/core/services';

package/dist/.pikku/variables/pikku-variables.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.49
+ * This file was generated by @pikku/cli@0.12.51
  */
 import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
 const VARIABLES_META = {};

package/dist/.pikku/workflow/pikku-workflow-types.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.49
+ * This file was generated by @pikku/cli@0.12.51
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import { template } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-types.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.49
+ * This file was generated by @pikku/cli@0.12.51
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import { template } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.49
+ * This file was generated by @pikku/cli@0.12.51
  */
 import { pikkuState } from '@pikku/core/internal';
 import allWorkflowMeta from './meta/allWorkflow.gen.json' with { type: 'json' };

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.49
+ * This file was generated by @pikku/cli@0.12.51
  */
 import { addWorkflow } from '@pikku/core/workflow';
 import './pikku-workflow-wirings-meta.gen.js';

package/dist/bin/pikku-bin.mjs

@@ -11,8 +11,8 @@ async function checkForUpdate() {
     })
     if (!res.ok) return
     const { version: latest } = await res.json()
-    if (latest !== '0.12.49') {
-      process.stderr.write(`\n  Update available  0.12.49 → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`)
+    if (latest !== '0.12.51') {
+      process.stderr.write(`\n  Update available  0.12.51 → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`)
     }
   } catch {}
 }

package/dist/src/deploy/build-pipeline.js

@@ -188,7 +188,8 @@ export async function runBuildPipeline(options) {
             await mkdir(unitDir, { recursive: true });
             const ctx = getEntryContext(unitDir, pikkuDir, unit, inspectorState);
             const source = unit.target === 'server'
-                ? generateServerEntrySource(ctx)
+                ? (provider.generateServerEntrySource?.(ctx) ??
+                    generateServerEntrySource(ctx))
                 : provider.generateEntrySource(ctx);
             await writeFile(entryPath, source, 'utf-8');
             if (unit.target === 'server') {

package/dist/src/deploy/provider-adapter.d.ts

@@ -59,6 +59,19 @@ export interface ProviderAdapter {
      * Called once per unit.
      */
     generateEntrySource(ctx: EntryGenerationContext): string;
+    /**
+     * Generate the entry file source for a `target: 'server'` (container) unit.
+     *
+     * Optional. When a provider implements it, the deploy pipeline uses it
+     * instead of the provider-agnostic `generateServerEntrySource`, so the
+     * provider can inject the SAME platform services (kysely, secrets, …) into
+     * the container that it injects into its serverless workers — sourcing the
+     * bindings from `process.env` instead of a runtime `env` object. When
+     * omitted, the pipeline falls back to the generic generator (no platform
+     * injection), which is correct for providers whose containers carry no
+     * platform services.
+     */
+    generateServerEntrySource?(ctx: EntryGenerationContext): string;
     /**
      * Generate provider-specific config files per unit (e.g. wrangler.toml).
      * Returns a map of filename → content to write into the unit directory.

package/dist/src/deploy/server-entry.d.ts

@@ -12,5 +12,5 @@
  */
 import type { EntryGenerationContext } from './provider-adapter.js';
 export declare function generateServerEntrySource(ctx: EntryGenerationContext): string;
-export declare const SERVER_DOCKERFILE = "# Generated by @pikku/cli \u2014 do not edit\nFROM node:22-slim\n\nRUN apt-get update \\\n  && apt-get install -y --no-install-recommends tini ca-certificates \\\n  && rm -rf /var/lib/apt/lists/*\n\nRUN groupadd -r pikku && useradd -r -g pikku -u 1001 pikku\n\nWORKDIR /app\n\n# Pikku bundles user code + first-party deps inline; only externalised deps\n# (typically empty for pure-JS apps) are listed in package.json. We ship no\n# lockfile because the bundle has already pinned everything via the\n# extracted exact-dependencies \u2014 `npm install --omit=dev` resolves the\n# leftover externals (if any) at build time.\nCOPY --chown=pikku:pikku package.json ./\nRUN npm install --omit=dev --no-audit --no-fund\n\nCOPY --chown=pikku:pikku bundle.js ./\n\nUSER pikku\nENV NODE_ENV=production\nENV PORT=8080\nEXPOSE 8080\n\nENTRYPOINT [\"/usr/bin/tini\", \"--\"]\nCMD [\"node\", \"bundle.js\"]\n";
+export declare const SERVER_DOCKERFILE = "# Generated by @pikku/cli \u2014 do not edit\n# Full image (not -slim): carries the build toolchain so externalised deps with\n# native addons can compile from source at `npm install` time.\nFROM node:26\n\nRUN apt-get update \\\n  && apt-get install -y --no-install-recommends tini ca-certificates \\\n  && rm -rf /var/lib/apt/lists/*\n\nRUN groupadd -r pikku && useradd -r -g pikku -u 1001 pikku\n\nWORKDIR /app\n\n# Pikku bundles user code + first-party deps inline; only externalised deps\n# (typically empty for pure-JS apps) are listed in package.json. We ship no\n# lockfile because the bundle has already pinned everything via the\n# extracted exact-dependencies \u2014 `npm install --omit=dev` resolves the\n# leftover externals (if any) at build time.\nCOPY --chown=pikku:pikku package.json ./\nRUN npm install --omit=dev --no-audit --no-fund\n\nCOPY --chown=pikku:pikku bundle.js ./\n\nUSER pikku\nENV NODE_ENV=production\nENV PORT=8080\nEXPOSE 8080\n\nENTRYPOINT [\"/usr/bin/tini\", \"--\"]\nCMD [\"node\", \"bundle.js\"]\n";
 export declare const SERVER_DOCKERIGNORE = "node_modules\n.git\n*.log\nmetafile.json\nexact-dependencies.json\n";

package/dist/src/deploy/server-entry.js

@@ -45,7 +45,9 @@ export function generateServerEntrySource(ctx) {
     return lines.join('\n');
 }
 export const SERVER_DOCKERFILE = `# Generated by @pikku/cli — do not edit
-FROM node:22-slim
+# Full image (not -slim): carries the build toolchain so externalised deps with
+# native addons can compile from source at \`npm install\` time.
+FROM node:26
 
 RUN apt-get update \\
   && apt-get install -y --no-install-recommends tini ca-certificates \\

package/dist/src/fabric/functions/validate.function.js

@@ -387,6 +387,12 @@ export async function runValidate(startDir = process.cwd()) {
             if (!fnPkg?.dependencies?.['@ai-sdk/openai-compatible']) {
                 e('missing-ai-sdk-openai-compatible', 'Project declares agent units but @ai-sdk/openai-compatible is not in packages/functions dependencies', fnPkgPath, 'Run `yarn add @ai-sdk/openai-compatible` in packages/functions — must be in dependencies, not devDependencies');
             }
+            // `ai` is a peer dep of @pikku/ai-vercel — not auto-installed. Without it
+            // `pikku dev` can't construct the agent runner and agents 503 with
+            // AIProviderNotConfiguredError.
+            if (!fnPkg?.dependencies?.['ai']) {
+                e('missing-ai-sdk-core', 'Project declares agent units but `ai` (the Vercel AI SDK) is not in packages/functions dependencies — it is a peer dependency of @pikku/ai-vercel and is not installed automatically', fnPkgPath, 'Run `yarn add ai` in packages/functions — must be in dependencies, not devDependencies');
+            }
         }
         // services.ts
         const servicesPath = join(fnDir, 'src', 'services.ts');

package/dist/src/fabric/lib/config.js

@@ -2,7 +2,7 @@ import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
-const DEFAULT_API_URL = 'http://localhost:7103';
+const DEFAULT_API_URL = 'https://api.pikkufabric.com';
 const projectConfigName = 'pikkufabric.config.json';
 const authFilePath = join(homedir(), '.fabric', 'auth.json');
 export async function findProjectConfig(startDir = process.cwd()) {

package/dist/src/functions/commands/dev-ai-runner.d.ts

@@ -0,0 +1,19 @@
+import type { Logger, VariablesService } from '@pikku/core/services';
+import type { AIAgentRunnerService } from '@pikku/core/services';
+/**
+ * Build the AI agent runner for `pikku dev` from env.
+ *
+ * Deployed agent units get their runner wired by the bundler; the dev server
+ * has no equivalent, so agents 503 with AIProviderNotConfiguredError unless we
+ * construct one here. When an OpenAI-compatible base URL + key are present
+ * (fabric injects LITELLM_PROXY_URL/LITELLM_API_KEY; the standard OPENAI_*
+ * vars are also honored) we point a single openai-compatible provider at it and
+ * register it under every common provider prefix. Returns undefined when no AI
+ * env is configured (agents stay disabled, with the clear downstream error) or
+ * when the AI SDK packages aren't installed in the project.
+ */
+export declare function createDevAIAgentRunner({ logger, projectRoot, variables, }: {
+    logger: Logger;
+    projectRoot: string;
+    variables: VariablesService;
+}): Promise<AIAgentRunnerService | undefined>;

package/dist/src/functions/commands/dev-ai-runner.js

@@ -0,0 +1,70 @@
+import { createRequire } from 'module';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+// Provider prefixes a fabric/proxy baseURL fronts. Models are written as
+// `openai/gpt-4o-mini`, `openai/deepseek-v4-flash`, etc. — the runner splits on
+// the first `/`, so the prefix only selects the provider entry and the bare
+// model name is forwarded to the OpenAI-compatible proxy, which routes it.
+const PROXY_PROVIDER_NAMES = [
+    'openai',
+    'anthropic',
+    'google',
+    'gemini',
+    'deepseek',
+    'xai',
+    'litellm',
+];
+/**
+ * Build the AI agent runner for `pikku dev` from env.
+ *
+ * Deployed agent units get their runner wired by the bundler; the dev server
+ * has no equivalent, so agents 503 with AIProviderNotConfiguredError unless we
+ * construct one here. When an OpenAI-compatible base URL + key are present
+ * (fabric injects LITELLM_PROXY_URL/LITELLM_API_KEY; the standard OPENAI_*
+ * vars are also honored) we point a single openai-compatible provider at it and
+ * register it under every common provider prefix. Returns undefined when no AI
+ * env is configured (agents stay disabled, with the clear downstream error) or
+ * when the AI SDK packages aren't installed in the project.
+ */
+export async function createDevAIAgentRunner({ logger, projectRoot, variables, }) {
+    // Pair the URL with its matching key — coalescing each var independently could
+    // combine an OPENAI_BASE_URL with a LITELLM_API_KEY (or vice versa) and
+    // misroute or 401 every call. Take a complete OpenAI pair first, else LiteLLM.
+    const openAIBaseURL = await variables.get('OPENAI_BASE_URL');
+    const openAIApiKey = await variables.get('OPENAI_API_KEY');
+    const liteLLMBaseURL = await variables.get('LITELLM_PROXY_URL');
+    const liteLLMApiKey = await variables.get('LITELLM_API_KEY');
+    const [baseURL, apiKey] = openAIBaseURL && openAIApiKey
+        ? [openAIBaseURL, openAIApiKey]
+        : liteLLMBaseURL && liteLLMApiKey
+            ? [liteLLMBaseURL, liteLLMApiKey]
+            : [undefined, undefined];
+    if (!baseURL || !apiKey) {
+        logger.debug('pikku dev: no AI provider env (OPENAI_BASE_URL/OPENAI_API_KEY or LITELLM_PROXY_URL/LITELLM_API_KEY) — AI agents disabled');
+        return undefined;
+    }
+    // Resolve from the project's node_modules — the AI SDK packages are the
+    // project's deps, not the CLI's, so they share the project's `ai` version.
+    const require = createRequire(pathToFileURL(join(projectRoot, 'package.json')).href);
+    let VercelAIAgentRunner;
+    let createOpenAICompatible;
+    try {
+        ;
+        ({ VercelAIAgentRunner } = await import(pathToFileURL(require.resolve('@pikku/ai-vercel')).href));
+        ({ createOpenAICompatible } = await import(pathToFileURL(require.resolve('@ai-sdk/openai-compatible')).href));
+    }
+    catch (error) {
+        logger.warn(`pikku dev: AI provider env is set but the AI SDK packages could not be loaded (install @pikku/ai-vercel, @ai-sdk/openai-compatible, and ai) — AI agents disabled: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+    const buildProviders = (key) => {
+        const provider = createOpenAICompatible({
+            name: 'pikku-dev',
+            baseURL,
+            apiKey: key,
+        });
+        return Object.fromEntries(PROXY_PROVIDER_NAMES.map((name) => [name, provider]));
+    };
+    logger.info(`pikku dev: AI agent runner wired to ${baseURL}`);
+    return new VercelAIAgentRunner(buildProviders(apiKey), buildProviders);
+}

package/dist/src/functions/commands/dev.js

@@ -15,6 +15,7 @@ import { WebSocketServer } from 'ws';
 import { InMemorySchedulerService } from '@pikku/schedule';
 import { resolveDb, createKysely, parseDatabaseUrl, } from '../db/local-db.js';
 import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
+import { createDevAIAgentRunner } from './dev-ai-runner.js';
 export const dev = pikkuSessionlessFunc({
     remote: true,
     func: async ({ logger, config, getInspectorState, variables }, { port, watch, hmr }, { rpc }) => {
@@ -153,8 +154,23 @@ export const dev = pikkuSessionlessFunc({
         // can read runs in dev without projects having to wire their own backing
         // store.
         const devLogger = new ConsoleLogger();
+        // Deployed agent units get their runner from the bundler; the dev server
+        // has no equivalent, so construct one from env or agents 503 with
+        // AIProviderNotConfiguredError. The template forwards injected services
+        // (`...existingServices`) so this reaches getSingletonServices().
+        // Only when the project declares agents — otherwise the runner's
+        // missing-SDK warning fires spuriously for projects with global AI env.
+        const hasAgents = Object.keys(inspectorState.agents.agentsMeta).length > 0;
+        const aiAgentRunner = hasAgents
+            ? await createDevAIAgentRunner({
+                logger,
+                projectRoot: config.rootDir,
+                variables,
+            })
+            : undefined;
         const inMemoryServices = {
             logger: devLogger,
+            ...(aiAgentRunner ? { aiAgentRunner } : {}),
             emailService: new LocalEmailService(),
             metaService: new LocalMetaService(pikkuDir),
             schedulerService,

package/dist/src/functions/commands/tests-coverage.js

@@ -165,6 +165,12 @@ export const pikkuTestsCoverage = pikkuSessionlessFunc({
                 '--require',
                 'tests/tests/support/**/*.ts',
                 'tests/tests/features/**/*.feature',
+                '--format',
+                'progress',
+                // Persist the HTML report so the console can parse scenarios back out
+                // of it (readAllMeta attaches them per function).
+                '--format',
+                'html:tests/tests/reports/cucumber-report.html',
             ], { cwd: functionsDir, stdio: 'inherit', env: spawnEnv });
             if (res.status !== 0) {
                 logger.error(`Test run failed (exit ${res.status})`);

package/dist/src/functions/db/db-codegen.d.ts

@@ -7,6 +7,13 @@ export interface CodegenOptions {
     manifestFile?: string;
     classificationMapFile?: string;
     schemaJsonFile?: string;
+    /**
+     * When set, emit a standalone module of bare enum unions (one
+     * `export type <Table><Column>` per enum column) — independent of the wrapped
+     * DB interface, so callers import a clean union instead of unwrapping
+     * `ColumnType<Private<…>>`.
+     */
+    enumsFile?: string;
     camelCase?: boolean;
     rootDir?: string;
     /** DB dialect — drives real-type-aware date typing. Defaults to 'sqlite'. */
@@ -17,10 +24,12 @@ export interface CodegenResult {
     coercionFile: string;
     manifestFile?: string;
     classificationMapFile?: string;
+    enumsFile?: string;
     written: boolean;
     coercionWritten: boolean;
     manifestWritten: boolean;
     classificationMapWritten: boolean;
+    enumsWritten: boolean;
     tables: string[];
     /** Non-fatal codegen warnings (e.g. name looks like a date but unannotated). */
     warnings: string[];
@@ -31,11 +40,5 @@ export interface CodegenResult {
      */
     zodFormats: Record<string, Record<string, ZodFormat>>;
 }
-/**
- * Introspect `introspector` and emit:
- *   - `schema.d.ts`            Kysely DB type with classification brands
- *   - `coercion.gen.ts`        Runtime CoercionMap for date/bool/json coercion
- *   - `classification.gen.ts`  Data-classification manifest (when manifestFile set)
- */
 export declare function generateSchemaTypes(introspector: DbIntrospector, options: CodegenOptions): Promise<CodegenResult>;
 export {};

package/dist/src/functions/db/db-codegen.js

@@ -177,11 +177,13 @@ function emitInterface(table, camelCase, explicitAnnotations, dialect, enumByNam
                     `is ${col.type} (${real}). If intentional, set its kind in db/annotations.ts.`);
             }
         }
-        // A Postgres enum column reports `type` as 'USER-DEFINED'; its real values
-        // come from `udtName`. Type it as a union of string literals — only when
-        // no explicit `tsType`/`kind` overrides it. This reuses the `tsType`
-        // plumbing, so it flows through both the public and classified branches.
-        const enumValues = col.udtName ? enumByName.get(col.udtName) : undefined;
+        // Enum columns are typed as a union of string literals — only when no
+        // explicit `tsType`/`kind` overrides it. This reuses the `tsType` plumbing,
+        // so it flows through both the public and classified branches. Values come
+        // from a Postgres enum (`type` is 'USER-DEFINED', real values via `udtName`)
+        // or, on SQLite, from a `CHECK (col IN (…))` constraint the introspector
+        // parsed onto `col.enumValues`.
+        const enumValues = col.enumValues ?? (col.udtName ? enumByName.get(col.udtName) : undefined);
         const enumUnion = enumValues && enumValues.length > 0
             ? enumValues.map((v) => `'${escapeTsString(v)}'`).join(' | ')
             : null;
@@ -322,6 +324,41 @@ function emitClassificationMap(tables) {
  *   - `coercion.gen.ts`        Runtime CoercionMap for date/bool/json coercion
  *   - `classification.gen.ts`  Data-classification manifest (when manifestFile set)
  */
+/**
+ * Bare string-literal enum types, independent of the wrapped DB interface. One
+ * `export type <Table><Column>` per enum column — Postgres native enums (values
+ * via `udtName`/`enumByName`) and SQLite `CHECK (col IN (…))` (values on
+ * `col.enumValues`) alike. Lets app code and i18n reconciliation import a clean
+ * union instead of unwrapping `ColumnType<Private<…>>` from the DB interface.
+ */
+function emitEnumsModule(tables, enumByName) {
+    const pascal = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+    const seen = new Set();
+    const lines = [];
+    for (const t of tables) {
+        const tablePart = pascal(snakeToCamel(bareTableName(t.name)));
+        for (const col of t.columns) {
+            const values = col.enumValues ?? (col.udtName ? enumByName.get(col.udtName) : undefined);
+            if (!values || values.length === 0)
+                continue;
+            const name = `${tablePart}${pascal(snakeToCamel(col.name))}`;
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            const union = values.map((v) => `'${escapeTsString(v)}'`).join(' | ');
+            lines.push(`export type ${name} = ${union}`);
+        }
+    }
+    return [
+        `// Generated by @pikku/cli — do not edit by hand.`,
+        `// Run \`pikku db migrate\` to refresh.`,
+        `//`,
+        `// Bare enum unions from Postgres enums and SQLite CHECK (col IN (…)) constraints.`,
+        ``,
+        ...(lines.length ? lines : ['export {}']),
+        ``,
+    ].join('\n');
+}
 export async function generateSchemaTypes(introspector, options) {
     const camelCase = options.camelCase ?? true;
     const dialect = options.dialect ?? 'sqlite';
@@ -456,6 +493,10 @@ export async function generateSchemaTypes(introspector, options) {
         schemaJsonBody =
             JSON.stringify({ tables: jsonTables, enums }, null, 2) + '\n';
     }
+    // ── enums.gen.ts ─────────────────────────────────────────────────────────────
+    const enumsBody = options.enumsFile
+        ? emitEnumsModule(tables, enumByName)
+        : null;
     // ── write files ───────────────────────────────────────────────────────────────
     let existingSchema = null;
     let existingCoercion = null;
@@ -498,12 +539,22 @@ export async function generateSchemaTypes(introspector, options) {
             /* ok */
         }
     }
+    let existingEnums = null;
+    if (options.enumsFile) {
+        try {
+            existingEnums = readFileSync(options.enumsFile, 'utf8');
+        }
+        catch {
+            /* ok */
+        }
+    }
     const schemaChanged = existingSchema !== schemaBody;
     const coercionChanged = existingCoercion !== coercionBody;
     const manifestChanged = manifestBody !== null && existingManifest !== manifestBody;
     const classificationMapChanged = classificationMapBody !== null &&
         existingClassificationMap !== classificationMapBody;
     const schemaJsonChanged = schemaJsonBody !== null && existingSchemaJson !== schemaJsonBody;
+    const enumsChanged = enumsBody !== null && existingEnums !== enumsBody;
     if (schemaChanged) {
         mkdirSync(dirname(options.outFile), { recursive: true });
         writeFileSync(options.outFile, schemaBody, 'utf8');
@@ -526,15 +577,21 @@ export async function generateSchemaTypes(introspector, options) {
         mkdirSync(dirname(options.schemaJsonFile), { recursive: true });
         writeFileSync(options.schemaJsonFile, schemaJsonBody, 'utf8');
     }
+    if (enumsChanged && options.enumsFile && enumsBody) {
+        mkdirSync(dirname(options.enumsFile), { recursive: true });
+        writeFileSync(options.enumsFile, enumsBody, 'utf8');
+    }
     return {
         outFile: options.outFile,
         coercionFile: options.coercionFile,
         manifestFile: options.manifestFile,
         classificationMapFile: options.classificationMapFile,
+        enumsFile: options.enumsFile,
         written: schemaChanged,
         coercionWritten: coercionChanged,
         manifestWritten: manifestChanged,
         classificationMapWritten: classificationMapChanged,
+        enumsWritten: enumsChanged,
         tables: tables.map((t) => t.name),
         warnings,
         zodFormats,

package/dist/src/functions/db/db-introspector.d.ts

@@ -13,6 +13,12 @@ export interface ColumnInfo {
      * name used to resolve its values. Undefined on SQLite (no native enums).
      */
     udtName?: string;
+    /**
+     * String-literal enum values for this column, when known. On SQLite (no native
+     * enums) these come from a `CHECK (col IN ('a','b',…))` constraint — the CHECK
+     * *is* the enum definition. Typed as a union, mirroring a Postgres enum column.
+     */
+    enumValues?: string[];
 }
 export interface ForeignKeyInfo {
     column: string;

package/dist/src/functions/db/local-db.d.ts

@@ -14,6 +14,7 @@ interface ResolvedDbBase {
     schemaJsonFile: string;
     classificationsFile: string;
     classificationsGenJsonFile: string;
+    enumsFile: string;
     zodFile: string;
     camelCase: boolean;
 }

package/dist/src/functions/db/local-db.js

@@ -47,6 +47,7 @@ export function resolveDb(userConfig, rootDir, outDir, runtimeDir) {
         manifestFile: join(outDir, 'db', 'classification.gen.ts'),
         classificationMapFile: join(outDir, 'db', 'classification-map.gen.d.ts'),
         schemaJsonFile: join(outDir, 'db', 'pikku-db-schema.gen.json'),
+        enumsFile: join(outDir, 'db', 'enums.gen.ts'),
         classificationsFile: join(rootDir, 'db', 'annotations.ts'),
         // Compiled sidecar lives beside the authored annotations.ts in db/ — this is
         // where both consumers read it: the codegen's loadAnnotations() and the
@@ -182,6 +183,7 @@ export async function migrateAndCodegen(resolved) {
                 manifestFile: resolved.manifestFile,
                 classificationMapFile: resolved.classificationMapFile,
                 schemaJsonFile: resolved.schemaJsonFile,
+                enumsFile: resolved.enumsFile,
                 camelCase: resolved.camelCase,
                 rootDir: resolved.rootDir,
                 dialect: 'sqlite',
@@ -204,6 +206,7 @@ export async function migrateAndCodegen(resolved) {
                     manifestFile: resolved.manifestFile,
                     classificationMapFile: resolved.classificationMapFile,
                     schemaJsonFile: resolved.schemaJsonFile,
+                    enumsFile: resolved.enumsFile,
                     camelCase: resolved.camelCase,
                     rootDir: resolved.rootDir,
                     dialect: 'postgres',

package/dist/src/functions/db/sqlite/sqlite-introspector.d.ts

@@ -5,6 +5,14 @@ export declare class SqliteIntrospector implements DbIntrospector {
     constructor(db: SyncSqliteDatabase);
     listTables(): Promise<string[]>;
     getColumns(table: string): Promise<ColumnInfo[]>;
+    /**
+     * SQLite has no native enums, but a `CHECK (col IN ('a','b',…))` constraint is
+     * an enum by another name. Parse the table's stored `CREATE TABLE` DDL and map
+     * each constrained column to its allowed values so codegen can type it as a
+     * union. Only the positive `col IN (…)` form is recognised (the convention);
+     * `NOT IN`, ranges, and boolean expressions are left as plain `string`.
+     */
+    private parseCheckEnums;
     getForeignKeys(table: string): Promise<ForeignKeyInfo[]>;
     listEnums(): Promise<EnumInfo[]>;
     close(): Promise<void>;

package/dist/src/functions/db/sqlite/sqlite-introspector.js

@@ -18,6 +18,7 @@ export class SqliteIntrospector {
         const rows = this.db
             .prepare(`PRAGMA table_xinfo(${escaped})`)
             .all();
+        const enumsByColumn = this.parseCheckEnums(table);
         return rows
             .filter((c) => c.hidden !== 1)
             .map((c) => ({
@@ -27,8 +28,34 @@ export class SqliteIntrospector {
             pk: c.pk > 0,
             defaultValue: c.dflt_value != null ? String(c.dflt_value) : null,
             generated: c.hidden === 2 || c.hidden === 3,
+            enumValues: enumsByColumn.get(c.name),
         }));
     }
+    /**
+     * SQLite has no native enums, but a `CHECK (col IN ('a','b',…))` constraint is
+     * an enum by another name. Parse the table's stored `CREATE TABLE` DDL and map
+     * each constrained column to its allowed values so codegen can type it as a
+     * union. Only the positive `col IN (…)` form is recognised (the convention);
+     * `NOT IN`, ranges, and boolean expressions are left as plain `string`.
+     */
+    parseCheckEnums(table) {
+        const out = new Map();
+        const row = this.db
+            .prepare(`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?`)
+            .get(table);
+        const ddl = row?.sql;
+        if (!ddl)
+            return out;
+        const checkIn = /CHECK\s*\(\s*"?(\w+)"?\s+IN\s*\(([^)]*)\)/gi;
+        let m;
+        while ((m = checkIn.exec(ddl))) {
+            const column = m[1];
+            const values = [...m[2].matchAll(/'((?:[^']|'')*)'/g)].map((q) => q[1].replace(/''/g, "'"));
+            if (values.length > 0)
+                out.set(column, values);
+        }
+        return out;
+    }
     async getForeignKeys(table) {
         const escaped = `"${table.replace(/"/g, '""')}"`;
         const rows = this.db

package/dist/src/scaffold/rpc-remote.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.49
+ * This file was generated by @pikku/cli@0.12.51
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint