@pikku/cli 0.11.2 → 0.12.0

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

@@ -0,0 +1,33 @@
+/**
+ * This file was generated by @pikku/cli@0.12.0
+ */
+/**
+ * Trigger-specific type definitions for tree-shaking optimization
+ */
+import { wireTrigger as wireTriggerCore, wireTriggerSource as wireTriggerSourceCore } from '@pikku/core/trigger';
+export function pikkuTriggerFunc(triggerOrConfig) {
+    if (typeof triggerOrConfig === 'function') {
+        return { func: triggerOrConfig };
+    }
+    return triggerOrConfig;
+}
+/**
+ * Registers a trigger with the Pikku framework.
+ * Declares a trigger name and its target pikku function.
+ * Runs everywhere — inspector extracts at build time.
+ *
+ * @param trigger - Trigger definition with name and function config
+ */
+export const wireTrigger = (trigger) => {
+    wireTriggerCore(trigger);
+};
+/**
+ * Registers a trigger source with the Pikku framework.
+ * Provides the subscription function and input data.
+ * Only imported in the trigger worker process.
+ *
+ * @param source - Trigger source with name, func, and input
+ */
+export const wireTriggerSource = (source) => {
+    wireTriggerSourceCore(source);
+};

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

@@ -0,0 +1,5 @@
+/**
+ * This file was generated by @pikku/cli@0.12.0
+ */
+export { wireVariable } from '@pikku/core/variable';
+export type { CoreVariable, VariableDefinitionMeta, VariableDefinitionsMeta } from '@pikku/core/variable';

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * This file was generated by @pikku/cli@0.12.0
+ */
+import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
+import type { VariablesService } from '@pikku/core/services';
+export interface VariablesMap {
+}
+export type VariableId = keyof VariablesMap;
+export declare class TypedVariablesService extends CoreTypedVariablesService<VariablesMap> {
+    constructor(variables: VariablesService);
+}

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

@@ -0,0 +1,10 @@
+/**
+ * This file was generated by @pikku/cli@0.12.0
+ */
+import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
+const VARIABLES_META = {};
+export class TypedVariablesService extends CoreTypedVariablesService {
+    constructor(variables) {
+        super(variables, VARIABLES_META);
+    }
+}

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

@@ -1,62 +1,80 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.12.0
  */
-/**
- * Workflow-specific type definitions for tree-shaking optimization
- */
-import { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow';
+import { WorkflowCancelledException } from '@pikku/core/workflow';
+import { template } from '@pikku/core/workflow';
+import { type PikkuWorkflowGraphConfig, type PikkuWorkflowGraphResult } from '@pikku/core/workflow';
+import type { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow';
+export { WorkflowCancelledException };
 import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '../function/pikku-function-types.gen.js';
-import type { RPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js';
-/**
- * Typed workflow wire with RPC awareness
- * Provides type-safe workflow.do() for RPC steps
- */
+import type { RPCMap, FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js';
+import type { WorkflowMap, GraphsMap } from './pikku-workflow-map.gen.d.js';
+export { template };
 export interface TypedWorkflow extends PikkuWorkflowWire {
-    /**
-     * Execute a workflow step with RPC invocation (typed based on available RPCs)
-     * @template K - RPC name from the RPC map
-     */
     do<K extends keyof RPCMap>(stepName: string, rpcName: K, data: RPCMap[K]['input'], options?: WorkflowStepOptions): Promise<RPCMap[K]['output']>;
-    /**
-     * Execute a workflow step with inline function
-     * @template T - Return type of the inline function
-     */
     do<T>(stepName: string, fn: () => T | Promise<T>, options?: WorkflowStepOptions): Promise<T>;
 }
-/**
- * Workflow function type with typed workflow service
- * Includes the workflow wire object with typed RPC methods
- */
 export type PikkuFunctionWorkflow<In = unknown, Out = never> = PikkuFunctionSessionless<In, Out, 'workflow'>;
-/**
- * Creates a workflow function with typed input and output.
- * Workflow functions have access to the workflow wire object for step execution.
- *
- * This is the permissive mode - workflows that don't conform to simple DSL will fall back
- * to basic extraction with a warning.
- *
- * @template In - Input type for the workflow
- * @template Out - Output type for the workflow
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- */
 export declare const pikkuWorkflowFunc: <In, Out = unknown>(func: PikkuFunctionWorkflow<In, Out> | PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>) => PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>;
-/**
- * Creates a simple workflow function with typed input and output.
- * Simple workflows must conform to the restricted DSL for static analysis.
- *
- * This is the strict mode - workflows that don't conform to simple DSL will cause
- * a critical error during inspection.
- *
- * Constraints:
- * - Must use only workflow.do() with RPC form (no inline functions)
- * - Only if/else, for..of, and Promise.all(array.map()) control flow allowed
- * - Step names must be unique (except across mutually exclusive branches)
- * - All workflow calls must be awaited
- *
- * @template In - Input type for the workflow
- * @template Out - Output type for the workflow
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- */
-export declare const pikkuSimpleWorkflowFunc: <In, Out = unknown>(func: PikkuFunctionWorkflow<In, Out> | PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>) => PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>;
+export declare const pikkuWorkflowComplexFunc: <In, Out = unknown>(func: PikkuFunctionWorkflow<In, Out> | PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>) => PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>;
+type TypedRef<T> = {
+    $ref: string;
+    path?: string;
+} & {
+    __phantomType?: T;
+};
+type TemplateString = {
+    $template: {
+        parts: string[];
+        expressions: Array<{
+            $ref: string;
+            path?: string;
+        }>;
+    };
+} & {
+    __brand: 'TemplateString';
+};
+type InputWithRefs<T> = {
+    [K in keyof T]?: T[K] | TypedRef<T[K]> | TypedRef<unknown> | TemplateString;
+};
+type NodeInputType<FuncMap extends Record<string, string>, K extends keyof FuncMap> = FuncMap[K] extends keyof FlattenedRPCMap ? InputWithRefs<FlattenedRPCMap[FuncMap[K]]['input']> : Record<string, unknown>;
+type NodeOutputKeys<FuncMap extends Record<string, string>, N extends string> = N extends keyof FuncMap ? FuncMap[N] extends keyof FlattenedRPCMap ? keyof FlattenedRPCMap[FuncMap[N]]['output'] & string : string : string;
+type RefFunction<FuncMap extends Record<string, string>> = {
+    <N extends Extract<keyof FuncMap, string>>(nodeId: N, path: NodeOutputKeys<FuncMap, N>): TypedRef<unknown>;
+    (nodeId: 'trigger' | '$item', path?: string): TypedRef<unknown>;
+};
+type TemplateFunction = (templateStr: string, refs: TypedRef<unknown>[]) => TemplateString;
+type GraphNodeConfigMap<FuncMap extends Record<string, string>> = {
+    [K in Extract<keyof FuncMap, string>]?: {
+        next?: NextConfig<Extract<keyof FuncMap, string>>;
+        input?: NodeInputType<FuncMap, K> | (() => NodeInputType<FuncMap, K>) | ((ref: RefFunction<FuncMap>, template: TemplateFunction) => NodeInputType<FuncMap, K>);
+        onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[];
+    };
+};
+type NextConfig<NodeIds extends string> = NodeIds | NodeIds[] | {
+    if: string;
+    then: NodeIds;
+    else?: NodeIds;
+};
+export declare function pikkuWorkflowGraph<const FuncMap extends Record<string, keyof FlattenedRPCMap & string>>(config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>): PikkuWorkflowGraphResult;
+export declare const workflow: <Name extends keyof WorkflowMap>(workflowName: Name, options?: {
+    pollIntervalMs?: number;
+}) => PikkuFunctionConfig<WorkflowMap[Name]["input"], WorkflowMap[Name]["output"], "session" | "rpc">;
+export declare const workflowStart: <Name extends keyof WorkflowMap>(workflowName: Name) => PikkuFunctionConfig<WorkflowMap[Name]["input"], {
+    runId: string;
+}, "session" | "rpc">;
+export declare const workflowStatus: <Name extends keyof WorkflowMap>(_workflowName: Name) => PikkuFunctionConfig<{
+    runId: string;
+}, {
+    id: string;
+    status: "running" | "completed" | "failed" | "cancelled";
+    output?: WorkflowMap[Name]["output"];
+    error?: {
+        message?: string;
+    };
+}, "session" | "rpc">;
+export declare const graphStart: <Name extends keyof GraphsMap, Node extends string & keyof GraphsMap[Name]>(graphName: Name, startNode: Node) => PikkuFunctionConfig<GraphsMap[Name][Node] extends {
+    input: infer I;
+} ? I : never, {
+    runId: string;
+}, "session" | "rpc">;

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

@@ -1,42 +1,30 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
- */
-/**
- * Workflow-specific type definitions for tree-shaking optimization
- */
-/**
- * Creates a workflow function with typed input and output.
- * Workflow functions have access to the workflow wire object for step execution.
- *
- * This is the permissive mode - workflows that don't conform to simple DSL will fall back
- * to basic extraction with a warning.
- *
- * @template In - Input type for the workflow
- * @template Out - Output type for the workflow
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
+ * This file was generated by @pikku/cli@0.12.0
  */
+import { WorkflowCancelledException } from '@pikku/core/workflow';
+import { workflow as coreWorkflow, workflowStart as coreWorkflowStart, workflowStatus as coreWorkflowStatus, graphStart as coreGraphStart, } from '@pikku/core/workflow';
+import { template } from '@pikku/core/workflow';
+import { pikkuWorkflowGraph as corePikkuWorkflowGraph, } from '@pikku/core/workflow';
+export { WorkflowCancelledException };
+export { template };
 export const pikkuWorkflowFunc = (func) => {
     return typeof func === 'function' ? { func } : func;
 };
-/**
- * Creates a simple workflow function with typed input and output.
- * Simple workflows must conform to the restricted DSL for static analysis.
- *
- * This is the strict mode - workflows that don't conform to simple DSL will cause
- * a critical error during inspection.
- *
- * Constraints:
- * - Must use only workflow.do() with RPC form (no inline functions)
- * - Only if/else, for..of, and Promise.all(array.map()) control flow allowed
- * - Step names must be unique (except across mutually exclusive branches)
- * - All workflow calls must be awaited
- *
- * @template In - Input type for the workflow
- * @template Out - Output type for the workflow
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- */
-export const pikkuSimpleWorkflowFunc = (func) => {
+export const pikkuWorkflowComplexFunc = (func) => {
     return typeof func === 'function' ? { func } : func;
 };
+export function pikkuWorkflowGraph(config) {
+    return corePikkuWorkflowGraph(config);
+}
+export const workflow = (workflowName, options) => {
+    return coreWorkflow(workflowName, options);
+};
+export const workflowStart = (workflowName) => {
+    return coreWorkflowStart(workflowName);
+};
+export const workflowStatus = (_workflowName) => {
+    return coreWorkflowStatus(_workflowName);
+};
+export const graphStart = (graphName, startNode) => {
+    return coreGraphStart(graphName, startNode);
+};

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

@@ -1,6 +1,6 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.12.0
  */
 import { pikkuState } from '@pikku/core';
-import metaData from './pikku-workflow-wirings-meta.gen.json' with { type: 'json' };
-pikkuState('workflows', 'meta', metaData);
+const workflowsMeta = {};
+pikkuState(null, 'workflows', 'meta', workflowsMeta);

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

@@ -1,8 +1,4 @@
+export {};
 /**
- * This file was generated by @pikku/cli@0.11.2
- */
-/**
- * Auto-generated workflow registrations
- * Do not edit manually - regenerate with 'npx pikku'
+ * This file was generated by @pikku/cli@0.12.0
  */
-export {};

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

@@ -1,8 +1,4 @@
+export {};
 /**
- * This file was generated by @pikku/cli@0.11.2
- */
-/**
- * Auto-generated workflow registrations
- * Do not edit manually - regenerate with 'npx pikku'
+ * This file was generated by @pikku/cli@0.12.0
  */
-export {};

package/dist/bin/pikku.js

@@ -1,50 +1,23 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { createConfig, createSingletonServices } from '../src/services.js';
-import { LocalVariablesService } from '@pikku/core/services';
-import { all as allCommand } from '../src/functions/commands/all.js';
-import { watch as watchCommand } from '../src/functions/commands/watch.js';
-// Import bootstrap if it exists
-try {
-    await import('../.pikku/pikku-bootstrap.gen.js');
-}
-catch {
-    // Bootstrap doesn't exist yet, continue anyway
-}
-const action = async (command, cliConfig) => {
-    const config = await createConfig(new LocalVariablesService(), cliConfig);
-    const services = await createSingletonServices(config);
-    if (command === 'watch') {
-        await watchCommand.func(services);
+import { existsSync } from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { dirname, join } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// 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);
+        await PikkuCLI(process.argv.slice(2));
+        process.exit(0);
     }
-    else {
-        await allCommand.func(services);
+    catch (error) {
+        console.error('Failed to run Pikku CLI:', error.message);
+        process.exit(1);
     }
-};
-const all = (program, name, description) => {
-    program
-        .command(name, { isDefault: name === 'all' })
-        .description(description)
-        .option('--pikku-config-type', 'The type of your pikku config object')
-        .option('--singleton-services-factory-type', 'The type of your singleton services factory')
-        .option('--session-services-factory-type', 'The type of your wire services factory')
-        .option('-c, --config <string>', 'The path to pikku cli config file')
-        .option('-t, --tags <tags...>', 'Which tags to filter by')
-        .option('--types <types...>', 'Which types to filter by (http, channel, queue, scheduler, rpc, mcp)')
-        .option('-d, --directories <directories...>', 'Which directories to filter by')
-        .option('-n, --names <names...>', 'Filter functions by name patterns (supports wildcards)')
-        .option('--httpMethods <methods...>', 'Filter HTTP routes by methods (comma-separated)')
-        .option('--httpRoutes <routes...>', 'Filter HTTP routes by route patterns (comma-separated)')
-        .option('-s, --silent', 'Silent mode - only show critical errors')
-        .option('--info', 'Show info messages and above (info, warn, error, critical)')
-        .option('--verbose', 'Show all debug messages (most detailed)')
-        .option('--loglevel <level>', 'Set explicit log level (trace, debug, info, warn, error, critical)')
-        .option('--state-output <path>', 'Save inspector state to JSON file for reuse')
-        .option('--state-input <path>', 'Load inspector state from JSON file (skips inspection)')
-        .action((c) => action(name, c));
-};
-const program = new Command('pikku');
-program.usage('[command]');
-all(program, 'all', 'Generate all pikku wirings and files');
-all(program, 'watch', 'Watch for changes in pikku files');
-program.parse(process.argv);
+}
+else {
+    console.error('Pikku CLI not found. Run build.sh first.');
+    process.exit(1);
+}

package/dist/src/cli.wiring.js

@@ -1,6 +1,6 @@
 import { pikkuSchemas } from './functions/wirings/functions/schemas.js';
-import { pikkuFetch } from './functions/wirings/fetch/index.js';
-import { pikkuWebSocketTyped } from './functions/wirings/channels/pikku-command-websocket-typed.js';
+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 { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js';
 import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js';
@@ -9,6 +9,9 @@ import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.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 { pikkuVersionsInit } from './functions/commands/versions-init.js';
+import { pikkuVersionsCheck } from './functions/commands/versions-check.js';
 // import { clientCLIRenderer } from './services.js'
 wireCLI({
     program: 'pikku',
@@ -77,6 +80,17 @@ wireCLI({
             func: watch,
             description: 'Watch for file changes and regenerate automatically',
         }),
+        console: pikkuCLICommand({
+            func: consoleCommand,
+            description: 'Start the Pikku Console UI with live file watching',
+            options: {
+                port: {
+                    description: 'Port for the console server',
+                    default: '51442',
+                    short: 'p',
+                },
+            },
+        }),
         schemas: pikkuCLICommand({
             func: pikkuSchemas,
             description: 'Generate JSON schemas for function input/output types',
@@ -105,5 +119,18 @@ wireCLI({
             func: pikkuNext,
             description: 'Generate Next.js backend and HTTP wrappers',
         }),
+        init: pikkuCLICommand({
+            func: pikkuVersionsInit,
+            description: 'Initialize project',
+            options: {
+                force: {
+                    description: 'Overwrite existing manifest',
+                },
+            },
+        }),
+        'versions-check': pikkuCLICommand({
+            func: pikkuVersionsCheck,
+            description: 'Validate function contracts against the version manifest',
+        }),
     },
 });

package/dist/src/functions/commands/all.d.ts

@@ -1 +1 @@
-export declare const all: any;
+export declare const all: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;