@pikku/cli 0.12.20 → 0.12.22

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

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.20
+ * This file was generated by @pikku/cli@0.12.22
  */
 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.20
+ * This file was generated by @pikku/cli@0.12.22
  */
 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.20
+ * This file was generated by @pikku/cli@0.12.22
  */
 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.20
+ * This file was generated by @pikku/cli@0.12.22
  */
 import { addWorkflow } from '@pikku/core/workflow';
 import './pikku-workflow-wirings-meta.gen.js';

package/dist/bin/pikku-bin.mjs

@@ -0,0 +1,23 @@
+process.removeAllListeners('warning')
+process.on('warning', (w) => {
+  if (w.name === 'ExperimentalWarning' && w.message.includes('SQLite')) return
+  process.stderr.write(`${w.name}: ${w.message}\n`)
+})
+async function checkForUpdate() {
+  if (process.env.CI || !process.stderr.isTTY) return
+  try {
+    const res = await fetch('https://registry.npmjs.org/@pikku/cli/latest', {
+      signal: AbortSignal.timeout(3000),
+    })
+    if (!res.ok) return
+    const { version: latest } = await res.json()
+    if (latest !== '0.12.22') {
+      process.stderr.write(`\n  Update available  0.12.22 → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`)
+    }
+  } catch {}
+}
+import { PikkuCLI } from '../.pikku/cli/pikku-cli.gen.js'
+const updateCheck = checkForUpdate()
+await PikkuCLI(process.argv.slice(2))
+await updateCheck
+process.exit(0)

package/dist/bin/pikku.js

@@ -1,15 +1,42 @@
 #!/usr/bin/env node
-import { existsSync } from 'fs';
+process.removeAllListeners('warning');
+process.on('warning', (w) => {
+    if (w.name === 'ExperimentalWarning' && w.message.includes('SQLite'))
+        return;
+    process.stderr.write(`${w.name}: ${w.message}\n`);
+});
+import { existsSync, readFileSync } from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { dirname, join } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+async function checkForUpdate() {
+    if (process.env.CI || !process.stderr.isTTY)
+        return;
+    try {
+        const { version: current } = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+        const res = await fetch('https://registry.npmjs.org/@pikku/cli/latest', {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok)
+            return;
+        const { version: latest } = (await res.json());
+        if (latest !== current) {
+            process.stderr.write(`\n  Update available  ${current} → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`);
+        }
+    }
+    catch {
+        // never block the CLI for a network check
+    }
+}
 // Use the generated Pikku CLI
 const pikkuCliPath = join(__dirname, '../.pikku/cli/pikku-cli.gen.js');
 if (existsSync(pikkuCliPath)) {
     try {
         const { PikkuCLI } = await import(pathToFileURL(pikkuCliPath).href);
+        const updateCheck = checkForUpdate();
         await PikkuCLI(process.argv.slice(2));
+        await updateCheck;
         process.exit(0);
     }
     catch (error) {

package/dist/src/cli.wiring.js

@@ -3,16 +3,23 @@ import { pikkuFetch } from './functions/runtimes/fetch/index.js';
 import { pikkuWebSocketTyped } from './functions/runtimes/websocket/pikku-command-websocket-typed.js';
 import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js';
 import { pikkuReactQuery } from './functions/wirings/rpc/pikku-command-react-query.js';
+import { pikkuTanStackStart } from './functions/runtimes/tanstack-start/pikku-command-tanstack-start.js';
 import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js';
 import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js';
 import { pikkuNext } from './functions/runtimes/nextjs/pikku-command-nextjs.js';
 import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js';
+import { fabricCommands } from './fabric/fabric-commands.js';
 import { all } from './functions/commands/all.js';
 import { bootstrap } from './functions/commands/bootstrap.js';
 import { watch } from './functions/commands/watch.js';
 import { consoleCommand } from './functions/commands/console.js';
 import { dev } from './functions/commands/dev.js';
+import { dbMigrate } from './functions/commands/db-migrate.js';
+import { dbSeed } from './functions/commands/db-seed.js';
+import { dbReset } from './functions/commands/db-reset.js';
 import { pikkuVersionsInit } from './functions/commands/versions-init.js';
+import { pikkuTestsInit } from './functions/commands/tests-init.js';
+import { pikkuTestsCoverage } from './functions/commands/tests-coverage.js';
 import { pikkuVersionsCheck } from './functions/commands/versions-check.js';
 import { pikkuVersionsUpdate } from './functions/commands/versions-update.js';
 import { pikkuNewFunction } from './functions/commands/new-function.js';
@@ -21,15 +28,19 @@ import { pikkuNewMiddleware } from './functions/commands/new-middleware.js';
 import { pikkuNewPermission } from './functions/commands/new-permission.js';
 import { pikkuNewAddon } from './functions/commands/new-addon.js';
 import { pikkuInfoFunctions, pikkuInfoTags, pikkuInfoMiddleware, pikkuInfoPermissions, } from './functions/commands/info.js';
-import { enableRpc, enableConsole, enableAgent, enableWorkflow, } from './functions/commands/enable.js';
+import { enableRpc, enableConsole, enableAgent, enableWorkflow, enableEvents, } from './functions/commands/enable.js';
+import { pikkuRealtime } from './functions/wirings/realtime/pikku-command-realtime.js';
+import { binary } from './functions/commands/binary.js';
 import { deployPlan } from './functions/commands/deploy-plan.js';
 import { deployApply } from './functions/commands/deploy-apply.js';
 import { deployInfo } from './functions/commands/deploy-info.js';
-// import { clientCLIRenderer } from './services.js'
+import { pikkuSkillsInstall, pikkuSkillsList, } from './functions/commands/skills.js';
+import { pikkuMetaFunctionsGet, pikkuMetaFunctionsList, pikkuMetaSchemasGet, pikkuMetaSchemasList, pikkuMetaMiddlewareGet, pikkuMetaMiddlewareList, pikkuMetaPermissionsGet, pikkuMetaPermissionsList, pikkuMetaWiresList, pikkuMetaWiresHttp, pikkuMetaWiresScheduler, pikkuMetaWiresQueue, pikkuMetaWiresChannel, pikkuMetaWiresTrigger, pikkuMetaWiresType, pikkuMetaWorkflowsGet, pikkuMetaWorkflowsList, pikkuMetaContext, pikkuMetaClients, } from './functions/commands/meta.js';
+import { defaultCLIRenderer } from './services.js';
 wireCLI({
     program: 'pikku',
     description: 'Pikku CLI - Code generation tool for type-safe backend development',
-    // render: clientCLIRenderer,
+    render: defaultCLIRenderer,
     options: {
         config: {
             description: 'Path to pikku.config.json file',
@@ -40,6 +51,16 @@ wireCLI({
             default: 'info',
             short: 'l',
         },
+        output: {
+            description: 'Output format (json emits NDJSON)',
+            choices: ['text', 'json'],
+            default: 'text',
+        },
+        json: {
+            description: 'Alias for --output json',
+            default: false,
+            short: 'j',
+        },
         userSessionType: {
             description: 'Specify which UserSession type to use (when multiple exist)',
         },
@@ -66,27 +87,54 @@ wireCLI({
             description: 'Generate all Pikku files (types, schemas, wirings, etc.)',
             isDefault: true,
             options: {
+                filter: {
+                    description: 'Named filter(s) from pikku.config.json filters map (comma-separated)',
+                },
                 tags: {
-                    description: 'Filter functions by tags (comma-separated)',
+                    description: 'Include functions by tags (comma-separated)',
                     short: 't',
                 },
-                types: {
-                    description: 'Filter functions by types (comma-separated)',
+                wires: {
+                    description: 'Filter direct wirings by category (comma-separated)',
+                },
+                excludeWires: {
+                    description: 'Exclude direct wirings by category (comma-separated)',
+                },
+                excludeTags: {
+                    description: 'Exclude functions by tags (comma-separated)',
                 },
                 directories: {
-                    description: 'Filter functions by directories (comma-separated)',
+                    description: 'Include functions by directories (comma-separated)',
                     short: 'd',
                 },
+                excludeDirectories: {
+                    description: 'Exclude functions by directories (comma-separated)',
+                },
                 httpMethods: {
-                    description: 'Filter HTTP routes by methods (comma-separated)',
+                    description: 'Include HTTP routes by methods (comma-separated)',
+                },
+                excludeHttpMethods: {
+                    description: 'Exclude HTTP routes by methods (comma-separated)',
                 },
                 httpRoutes: {
-                    description: 'Filter HTTP routes by route patterns (comma-separated)',
+                    description: 'Include HTTP routes by route patterns (comma-separated)',
+                },
+                excludeHttpRoutes: {
+                    description: 'Exclude HTTP routes by route patterns (comma-separated)',
                 },
                 names: {
-                    description: 'Filter functions by name patterns (supports wildcards)',
+                    description: 'Include functions by name patterns (supports wildcards)',
                     short: 'n',
                 },
+                excludeNames: {
+                    description: 'Exclude functions by name patterns (supports wildcards)',
+                },
+                target: {
+                    description: 'Include functions by deploy target (comma-separated: serverless, server)',
+                },
+                excludeTarget: {
+                    description: 'Exclude functions by deploy target (comma-separated: serverless, server)',
+                },
             },
         }),
         bootstrap: pikkuCLICommand({
@@ -146,6 +194,27 @@ wireCLI({
             func: pikkuSchemas,
             description: 'Generate JSON schemas for function input/output types',
         }),
+        db: {
+            description: 'Local development database commands',
+            subcommands: {
+                migrate: pikkuCLICommand({
+                    func: dbMigrate,
+                    description: 'Apply pending SQL migrations and regenerate db/schema.d.ts',
+                }),
+                seed: pikkuCLICommand({
+                    func: dbSeed,
+                    description: 'Apply db/seed.sql to the dev database',
+                }),
+                reset: pikkuCLICommand({
+                    func: dbReset,
+                    description: 'Wipe and recreate the dev database (migrate + seed)',
+                }),
+            },
+        },
+        fabric: {
+            description: 'PikkuFabric commands (login, link, deploy, domains, secrets, logs, …)',
+            subcommands: fabricCommands,
+        },
         fetch: pikkuCLICommand({
             func: pikkuFetch,
             description: 'Generate type-safe HTTP fetch client',
@@ -162,6 +231,14 @@ wireCLI({
             func: pikkuReactQuery,
             description: 'Generate React Query hooks from RPC map',
         }),
+        'tanstack-start': pikkuCLICommand({
+            func: pikkuTanStackStart,
+            description: 'Generate the TanStack Start server-function shim (makeApi)',
+        }),
+        realtime: pikkuCLICommand({
+            func: pikkuRealtime,
+            description: 'Generate the typed realtime client (PikkuRealtime websocket + SSE helper)',
+        }),
         'queue-service': pikkuCLICommand({
             func: pikkuQueueService,
             description: 'Generate queue service wrapper',
@@ -217,6 +294,16 @@ wireCLI({
                         },
                     },
                 }),
+                events: pikkuCLICommand({
+                    func: enableEvents,
+                    description: 'Enable the realtime events channel + SSE stream (scaffolds events.gen.ts)',
+                    options: {
+                        noAuth: {
+                            description: 'Disable auth requirement',
+                            default: false,
+                        },
+                    },
+                }),
             },
         },
         new: {
@@ -323,6 +410,29 @@ wireCLI({
                 }),
             },
         },
+        tests: {
+            description: 'Manage function tests',
+            subcommands: {
+                init: pikkuCLICommand({
+                    func: pikkuTestsInit,
+                    description: 'Scaffold the ftest Cucumber harness in your functions package',
+                    options: {
+                        force: {
+                            description: 'Overwrite existing ftest directory',
+                        },
+                    },
+                }),
+                coverage: pikkuCLICommand({
+                    func: pikkuTestsCoverage,
+                    description: 'Run the tests suite under c8 and emit tests/coverage/function-coverage.json',
+                    options: {
+                        noRun: {
+                            description: 'Skip running the suite and only re-analyse an existing coverage-final.json',
+                        },
+                    },
+                }),
+            },
+        },
         versions: {
             description: 'Manage function contract versions',
             subcommands: {
@@ -345,6 +455,15 @@ wireCLI({
                 }),
             },
         },
+        binary: pikkuCLICommand({
+            func: binary,
+            description: 'Compile a TypeScript entrypoint to a self-contained native binary using bun build --compile',
+            options: {
+                compileTarget: {
+                    description: 'Override compilation target (e.g. bun-linux-x64). Defaults to targets in pikku.config.json.',
+                },
+            },
+        }),
         deploy: {
             description: 'Deploy Pikku project to cloud infrastructure',
             subcommands: {
@@ -393,6 +512,163 @@ wireCLI({
                 }),
             },
         },
+        skills: {
+            description: 'Install bundled agent skills (Claude Code today; Codex/Gemini coming soon)',
+            subcommands: {
+                list: pikkuCLICommand({
+                    func: pikkuSkillsList,
+                    description: 'List skills bundled with @pikku/cli and which are installed',
+                }),
+                install: pikkuCLICommand({
+                    func: pikkuSkillsInstall,
+                    description: 'Copy bundled skills into the current project',
+                    options: {
+                        agent: {
+                            description: 'Target agent (claude | opencode | codex | gemini). Default: claude',
+                            default: 'claude',
+                        },
+                        only: {
+                            description: 'Comma-separated list of skill names to install (default: all)',
+                        },
+                        core: {
+                            description: 'Install skills whose frontmatter includes installGroups: [core]',
+                            default: false,
+                        },
+                        fabric: {
+                            description: 'Install skills whose frontmatter includes installGroups: [fabric]',
+                            default: false,
+                        },
+                        update: {
+                            description: 'Overwrite existing skills if already installed',
+                            default: false,
+                        },
+                    },
+                }),
+            },
+        },
+        meta: {
+            description: 'Inspect project metadata in machine-readable form',
+            subcommands: {
+                context: pikkuCLICommand({
+                    func: pikkuMetaContext,
+                    description: 'Bulk project context for planners (functions, wires, middleware, permissions, workflows, capabilities, layout) in one call',
+                }),
+                clients: pikkuCLICommand({
+                    func: pikkuMetaClients,
+                    description: 'Frontend-targeted metadata: exposed RPCs, workflows, channels with their input/output type names and descriptions',
+                }),
+                functions: {
+                    func: pikkuMetaFunctionsList,
+                    description: 'Inspect function metadata',
+                    subcommands: {
+                        list: pikkuCLICommand({
+                            func: pikkuMetaFunctionsList,
+                            description: 'List available functions (lightweight index)',
+                        }),
+                        get: pikkuCLICommand({
+                            func: pikkuMetaFunctionsGet,
+                            description: 'Get full metadata for a function id',
+                            parameters: '<functionId>',
+                        }),
+                    },
+                },
+                schemas: {
+                    func: pikkuMetaSchemasList,
+                    description: 'Inspect generated JSON schemas',
+                    subcommands: {
+                        list: pikkuCLICommand({
+                            func: pikkuMetaSchemasList,
+                            description: 'List generated JSON schema names',
+                        }),
+                        get: pikkuCLICommand({
+                            func: pikkuMetaSchemasGet,
+                            description: 'Get one generated JSON schema by name',
+                            parameters: '<schemaName>',
+                        }),
+                    },
+                },
+                workflows: {
+                    func: pikkuMetaWorkflowsList,
+                    description: 'Inspect workflow metadata',
+                    subcommands: {
+                        list: pikkuCLICommand({
+                            func: pikkuMetaWorkflowsList,
+                            description: 'List available workflows (lightweight index)',
+                        }),
+                        get: pikkuCLICommand({
+                            func: pikkuMetaWorkflowsGet,
+                            description: 'Get full metadata for a workflow id',
+                            parameters: '<workflowId>',
+                        }),
+                    },
+                },
+                middleware: {
+                    func: pikkuMetaMiddlewareList,
+                    description: 'Inspect middleware metadata',
+                    subcommands: {
+                        list: pikkuCLICommand({
+                            func: pikkuMetaMiddlewareList,
+                            description: 'List available middleware (lightweight index)',
+                        }),
+                        get: pikkuCLICommand({
+                            func: pikkuMetaMiddlewareGet,
+                            description: 'Get full metadata for a middleware id',
+                            parameters: '<middlewareId>',
+                        }),
+                    },
+                },
+                permissions: {
+                    func: pikkuMetaPermissionsList,
+                    description: 'Inspect permission metadata',
+                    subcommands: {
+                        list: pikkuCLICommand({
+                            func: pikkuMetaPermissionsList,
+                            description: 'List available permissions (lightweight index)',
+                        }),
+                        get: pikkuCLICommand({
+                            func: pikkuMetaPermissionsGet,
+                            description: 'Get full metadata for a permission id',
+                            parameters: '<permissionId>',
+                        }),
+                    },
+                },
+                wires: {
+                    func: pikkuMetaWiresList,
+                    description: 'Inspect wire metadata',
+                    subcommands: {
+                        list: pikkuCLICommand({
+                            func: pikkuMetaWiresList,
+                            description: 'List available wire types and counts',
+                        }),
+                        http: pikkuCLICommand({
+                            func: pikkuMetaWiresHttp,
+                            description: 'List HTTP wire entries',
+                        }),
+                        scheduler: pikkuCLICommand({
+                            func: pikkuMetaWiresScheduler,
+                            description: 'List scheduler wire entries',
+                        }),
+                        queue: pikkuCLICommand({
+                            func: pikkuMetaWiresQueue,
+                            description: 'List queue wire entries',
+                        }),
+                        channel: pikkuCLICommand({
+                            func: pikkuMetaWiresChannel,
+                            description: 'List channel wire entries',
+                        }),
+                        trigger: pikkuCLICommand({
+                            func: pikkuMetaWiresTrigger,
+                            description: 'List trigger wire entries',
+                        }),
+                        get: pikkuCLICommand({
+                            func: pikkuMetaWiresType,
+                            description: 'Get wire entries for a type',
+                            parameters: '<type>',
+                        }),
+                    },
+                },
+            },
+        },
         info: pikkuCLICommand({
             func: pikkuInfoFunctions,
             description: 'Show information about Pikku project resources',

package/dist/src/deploy/analyzer/analyzer.d.ts

@@ -6,12 +6,27 @@
  * Gateways (MCP, agents, channels) dispatch to function units via RPC.
  * Workflow orchestrators dispatch to step units via queue or RPC (inline).
  */
-import type { InspectorState } from '@pikku/inspector';
+import { type InspectorState } from '@pikku/inspector';
 import type { DeploymentManifest } from './manifest.js';
 export interface AnalyzerOptions {
     projectId: string;
     /** Services that can't run serverless — functions using them get target: 'server' */
     serverlessIncompatible?: string[];
+    /**
+     * When `true` (default), the analyzer synthesizes a per-workflow
+     * orchestrator queue + a per-step queue, plus the matching producer
+     * bindings, so providers whose workflow runtime fans out via queues
+     * have everything they need.
+     *
+     * Set to `false` for providers whose workflow runtime dispatches steps
+     * natively (e.g. Cloudflare's DO-backed `CloudflareWorkflowService`).
+     * In that case no `wf-orchestrator-*` / `wf-step-*` queues are added
+     * to `manifest.queues` and the orchestrator unit is emitted with no
+     * `{ type: 'queue' }` handler — only the HTTP routes.
+     *
+     * Queues created via explicit `wireQueue(...)` user code are unaffected.
+     */
+    workflowQueues?: boolean;
 }
 export declare function analyzeDeployment(state: InspectorState, options: AnalyzerOptions): DeploymentManifest;
 export declare function toSafeKebab(str: string): string;