@pikku/cli 0.11.1 → 0.11.3

package/.pikku/services/secrets.gen.json

@@ -0,0 +1,13 @@
+{
+  "name": "secrets",
+  "summary": "Interface for retrieving secrets.",
+  "description": "",
+  "package": "@pikku/core",
+  "path": "../core/dist/types/core.types.d.ts",
+  "version": "0.11.2",
+  "interface": "export interface SecretService {\n    /**\n     * Retrieves a secret by key.\n     * @param key - The key of the secret to retrieve.\n     * @returns A promise that resolves to the secret value.\n     */\n    getSecretJSON<Return = {}>(key: string): Promise<Return>;\n    /**\n     * Retrieves a secret by key.\n     * @param key - The key of the secret to retrieve.\n     * @returns A promise that resolves to the secret value.\n     */\n    getSecret(key: string): Promise<string>;\n}",
+  "expandedProperties": {
+    "getSecretJSON": "<Return = {}>(key: string) => Promise<Return>",
+    "getSecret": "(key: string) => Promise<string>"
+  }
+}

package/.pikku/services/variables.gen.json

@@ -0,0 +1,13 @@
+{
+  "name": "variables",
+  "summary": "",
+  "description": "",
+  "package": "@pikku/core",
+  "path": "../core/dist/types/core.types.d.ts",
+  "version": "0.11.2",
+  "interface": "export interface VariablesService {\n    get: (name: string) => Promise<string | undefined> | string | undefined;\n    getAll: () => Promise<Record<string, string | undefined>> | Record<string, string | undefined>;\n}",
+  "expandedProperties": {
+    "get": "(name: string) => Promise<string | undefined> | string | undefined",
+    "getAll": "() => Promise<Record<string, string | undefined>> | Record<string, string | undefined>"
+  }
+}

package/.pikku/services/workflowService.gen.json

@@ -0,0 +1,31 @@
+{
+  "name": "workflowService",
+  "summary": "Interface for workflow orchestration",
+  "description": "Handles workflow execution, replay, orchestration logic, and run-level state",
+  "package": "@pikku/core",
+  "path": "../core/dist/types/core.types.d.ts",
+  "version": "0.11.2",
+  "interface": "export interface WorkflowService {\n    createRun(workflowName: string, input: any, inline?: boolean): Promise<string>;\n    getRun(id: string): Promise<WorkflowRun | null>;\n    getRunHistory(runId: string): Promise<Array<StepState & {\n        stepName: string;\n    }>>;\n    updateRunStatus(id: string, status: WorkflowStatus, output?: any, error?: SerializedError): Promise<void>;\n    withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>;\n    close(): Promise<void>;\n    resumeWorkflow(runId: string): Promise<void>;\n    setServices(singletonServices: CoreSingletonServices, createWireServices: CreateWireServices, config: CoreConfig): void;\n    startWorkflow<I>(name: string, input: I, rpcService: any, options?: {\n        inline?: boolean;\n        startNode?: string;\n    }): Promise<{\n        runId: string;\n    }>;\n    runWorkflowJob(runId: string, rpcService: any): Promise<void>;\n    orchestrateWorkflow(runId: string, rpcService: any): Promise<void>;\n    executeWorkflowSleepCompleted(runId: string, stepId: string): Promise<void>;\n    insertStepState(runId: string, stepName: string, rpcName: string, data: any, stepOptions?: {\n        retries?: number;\n        retryDelay?: string | number;\n    }): Promise<StepState>;\n    getStepState(runId: string, stepName: string): Promise<StepState>;\n    setStepRunning(stepId: string): Promise<void>;\n    setStepScheduled(stepId: string): Promise<void>;\n    setStepResult(stepId: string, result: any): Promise<void>;\n    setStepError(stepId: string, error: Error): Promise<void>;\n    createRetryAttempt(stepId: string, status: 'pending' | 'running'): Promise<StepState>;\n    executeWorkflowStep(runId: string, stepName: string, rpcName: string | null, data: any, rpcService: any): Promise<void>;\n}",
+  "expandedProperties": {
+    "createRun": "(workflowName: string, input: any, inline?: boolean) => Promise<string>",
+    "getRun": "(id: string) => Promise<WorkflowRun | null>",
+    "getRunHistory": "(runId: string) => Promise<Array<StepState & { stepName: string; }>>",
+    "updateRunStatus": "(id: string, status: WorkflowStatus, output?: any, error?: SerializedError) => Promise<void>",
+    "withRunLock": "<T>(id: string, fn: () => Promise<T>) => Promise<T>",
+    "close": "() => Promise<void>",
+    "resumeWorkflow": "(runId: string) => Promise<void>",
+    "setServices": "(singletonServices: CoreSingletonServices, createWireServices: CreateWireServices, config: CoreConfig) => void",
+    "startWorkflow": "<I>(name: string, input: I, rpcService: any, options?: { inline?: boolean; startNode?: string; }) => Promise<{ runId: string; }>",
+    "runWorkflowJob": "(runId: string, rpcService: any) => Promise<void>",
+    "orchestrateWorkflow": "(runId: string, rpcService: any) => Promise<void>",
+    "executeWorkflowSleepCompleted": "(runId: string, stepId: string) => Promise<void>",
+    "insertStepState": "(runId: string, stepName: string, rpcName: string, data: any, stepOptions?: { retries?: number; retryDelay?: string | number; }) => Promise<StepState>",
+    "getStepState": "(runId: string, stepName: string) => Promise<StepState>",
+    "setStepRunning": "(stepId: string) => Promise<void>",
+    "setStepScheduled": "(stepId: string) => Promise<void>",
+    "setStepResult": "(stepId: string, result: any) => Promise<void>",
+    "setStepError": "(stepId: string, error: Error) => Promise<void>",
+    "createRetryAttempt": "(stepId: string, status: \"pending\" | \"running\") => Promise<StepState>",
+    "executeWorkflowStep": "(runId: string, stepName: string, rpcName: string | null, data: any, rpcService: any) => Promise<void>"
+  }
+}

package/.pikku/workflow/pikku-workflow-map.gen.d.ts

@@ -1,28 +1,12 @@
 /**
- * This file was generated by @pikku/cli@0.11.1
+ * This file was generated by @pikku/cli@0.11.3
  */
 /**
- * This provides the structure needed for TypeScript to be aware of workflows and their input/output types
+ * Workflow type map with input/output types for each workflow
  */
 
 
 
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-export type PikkuSchemasOutput = false | true
-export type PikkuChannelsOutput = false | true
-export type PikkuCLIOutput = false | true
-export type PikkuFunctionsOutput = false | true
-export type PikkuHTTPOutput = false | true
-export type PikkuMCPOutput = false | true
-export type PikkuMiddlewareOutput = false | true
-export type PikkuPermissionsOutput = false | true
-export type PikkuQueueOutput = false | true
-export type PikkuPublicRPCOutput = false | true
-export type PikkuRemoteRPCOutput = false | true
-export type PikkuRPCOutput = false | true
-export type PikkuSchedulerOutput = false | true
-export type PikkuWorkflowOutput = false | true
 
 interface WorkflowHandler<I, O> {
     input: I;
@@ -33,30 +17,12 @@ export type WorkflowMap = {
 };
 
 
-/**
- * Type-safe workflow client API
- */
 export type WorkflowClient<Name extends keyof WorkflowMap> = {
-  /**
-   * Start a new workflow run
-   */
   start: (input: WorkflowMap[Name]['input']) => Promise<{ runId: string }>;
-
-  /**
-   * Get a workflow run by ID
-   */
   getRun: <output extends keyof WorkflowMap[Name]>(runId: string) => Promise<WorkflowMap[Name][output]>;
-
-  /**
-   * Cancel a running workflow
-   */
   cancelRun: (runId: string) => Promise<boolean>;
 }
 
-/**
- * Map of all registered workflows with type-safe client APIs
- */
 export type TypedWorkflowClients = {
   [Name in keyof WorkflowMap]: WorkflowClient<Name>;
 }
-  

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

@@ -1,33 +1,29 @@
 /**
- * This file was generated by @pikku/cli@0.11.1
+ * This file was generated by @pikku/cli@0.11.3
  */
 /**
- * Workflow-specific type definitions for tree-shaking optimization
+ * Workflow type definitions and helpers
+ * Used for authoring both DSL and graph-based workflows
  */
 
-import { CoreWorkflow, wireWorkflow as wireWorkflowCore, PikkuWorkflowInteraction, WorkflowStepOptions } from '@pikku/core/workflow'
-import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '@pikku/core'
-import type { PikkuPermission, PikkuMiddleware } from '../function/pikku-function-types.gen.js'
-import type { UserSession, SingletonServices } from '../../types/application-types.d.js'
-import type { TypedPikkuRPC, RPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js'
+import { PikkuWorkflowWire, WorkflowStepOptions, WorkflowCancelledException } from '@pikku/core/workflow'
 
-/**
- * Type definition for workflows that orchestrate multi-step processes.
- * Workflows support both inline and remote execution modes with step caching.
- */
-type WorkflowWiring = CoreWorkflow<
-  CorePikkuFunctionConfig<PikkuFunctionWorkflow<any, any>, PikkuPermission<any>, PikkuMiddleware>
->
+// Re-export WorkflowCancelledException for use in workflow functions
+export { WorkflowCancelledException }
+import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '../function/pikku-function-types.gen.js'
+import type { RPCMap, FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js'
+import type { GraphNodeConfig, HTTPMethod } from '@pikku/core'
+import { createGraph, wireWorkflow as coreWireWorkflow } from '@pikku/core'
+
+// ============================================================================
+// DSL Workflow Types (pikkuWorkflowFunc, pikkuWorkflowComplexFunc)
+// ============================================================================
 
 /**
- * Typed workflow interaction with RPC awareness
+ * Typed workflow wire with RPC awareness
  * Provides type-safe workflow.do() for RPC steps
  */
-export interface TypedWorkflow extends PikkuWorkflowInteraction {
-  /**
-   * Execute a workflow step with RPC invocation (typed based on available RPCs)
-   * @template K - RPC name from the RPC map
-   */
+export interface TypedWorkflow extends PikkuWorkflowWire {
   do<K extends keyof RPCMap>(
     stepName: string,
     rpcName: K,
@@ -35,10 +31,6 @@ export interface TypedWorkflow extends PikkuWorkflowInteraction {
     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>,
@@ -48,45 +40,310 @@ export interface TypedWorkflow extends PikkuWorkflowInteraction {
 
 /**
  * Workflow function type with typed workflow service
- * Includes the workflow interaction object with typed RPC methods
  */
 export type PikkuFunctionWorkflow<
   In = unknown,
   Out = never
-> = CorePikkuFunctionSessionless<
-  In,
-  Out,
-  null,
-  SingletonServices & {
-    rpc: TypedPikkuRPC
-    workflow: TypedWorkflow
-  },
-  UserSession
->
+> = PikkuFunctionSessionless<In, Out, 'workflow'>
 
 /**
- * Creates a workflow function with typed input and output.
- * Workflow functions have access to the workflow interaction object for step execution.
- *
- * @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
+ * Creates a DSL-compatible workflow function (serializable, shows in Forge UI)
  */
 export const pikkuWorkflowFunc = <In, Out = unknown>(
   func:
     | PikkuFunctionWorkflow<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunctionWorkflow<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+    | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a complex workflow function (arbitrary code, hidden from Forge UI)
+ */
+export const pikkuWorkflowComplexFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionWorkflow<In, Out>
+    | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
 
+// ============================================================================
+// Graph Workflow Types (pikkuWorkflowGraph)
+// ============================================================================
+
+/**
+ * Type-safe graph builder with full RPC autocomplete
+ */
+const graphBuilder = createGraph<FlattenedRPCMap>()
+
+/** HTTP wire configuration for graph workflows */
+interface GraphHttpWire<NodeIds extends string> {
+  route: string
+  method: HTTPMethod
+  startNode: NodeIds
+}
+
+/** Channel wire configuration for graph workflows */
+interface GraphChannelWire<NodeIds extends string> {
+  name: string
+  onConnect?: NodeIds
+  onDisconnect?: NodeIds
+  onMessage?: NodeIds
+}
+
+/** Queue wire configuration for graph workflows */
+interface GraphQueueWire<NodeIds extends string> {
+  name: string
+  startNode: NodeIds
+}
+
+/** CLI wire configuration for graph workflows */
+interface GraphCliWire<NodeIds extends string> {
+  command: string
+  startNode: NodeIds
+}
+
+/** MCP wire configurations for graph workflows */
+interface GraphMcpWires<NodeIds extends string> {
+  tool?: Array<{ name: string; startNode: NodeIds }>
+  prompt?: Array<{ name: string; startNode: NodeIds }>
+  resource?: Array<{ uri: string; startNode: NodeIds }>
+}
+
+/** Schedule wire configuration for graph workflows */
+interface GraphScheduleWire<NodeIds extends string> {
+  cron?: string
+  interval?: string
+  startNode: NodeIds
+}
+
+/** Trigger wire configuration for graph workflows */
+interface GraphTriggerWire<NodeIds extends string> {
+  name: string  // RPC name of the trigger function
+  startNode: NodeIds
+}
+
+/** All wire configurations for graph workflows */
+interface GraphWiresConfig<NodeIds extends string> {
+  http?: Array<GraphHttpWire<NodeIds>>
+  channel?: Array<GraphChannelWire<NodeIds>>
+  queue?: Array<GraphQueueWire<NodeIds>>
+  cli?: Array<GraphCliWire<NodeIds>>
+  mcp?: GraphMcpWires<NodeIds>
+  schedule?: Array<GraphScheduleWire<NodeIds>>
+  trigger?: Array<GraphTriggerWire<NodeIds>>
+}
+
+/** Configuration for graph-based workflow */
+export interface PikkuWorkflowGraphConfig<
+  FuncMap extends Record<string, keyof FlattenedRPCMap & string>,
+  T
+> {
+  /** Workflow name (optional - defaults to exported variable name) */
+  name?: string
+  /** Optional description */
+  description?: string
+  /** Optional tags for organization */
+  tags?: string[]
+  /** Node to RPC function mapping */
+  nodes: FuncMap
+  /** Wire configurations - how this workflow can be triggered */
+  wires?: GraphWiresConfig<Extract<keyof FuncMap, string>>
+  /** Node configurations (next, input, onError) */
+  config?: T
+}
+
+/** Result of pikkuWorkflowGraph - includes metadata for wiring */
+export interface PikkuWorkflowGraphResult<T, NodeIds extends string = string> {
+  __type: 'pikkuWorkflowGraph'
+  name?: string
+  description?: string
+  tags?: string[]
+  wires?: GraphWiresConfig<NodeIds>
+  graph: T
+}
+
 /**
- * Registers a workflow with the Pikku framework.
- * Workflows can run in 'inline' (synchronous) or 'remote' (queue-based) execution modes.
+ * Creates a graph-based workflow definition with metadata
+ * Name defaults to the exported variable name if not provided.
+ *
+ * @example
+ * // Name inferred from exported variable name
+ * export const myWorkflow = pikkuWorkflowGraph({
+ *   description: 'Handles user onboarding',
+ *   tags: ['onboarding'],
+ *   nodes: {
+ *     entry: 'createUser',
+ *     sendEmail: 'sendWelcomeEmail',
+ *   },
+ *   config: {
+ *     entry: { next: 'sendEmail' },
+ *     sendEmail: { input: (ref) => ({ to: ref('entry', 'email') }) },
+ *   },
+ * })
+ */
+export function pikkuWorkflowGraph<
+  const FuncMap extends Record<string, keyof FlattenedRPCMap & string>
+>(
+  config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>
+): PikkuWorkflowGraphResult<Record<Extract<keyof FuncMap, string>, GraphNodeConfig<Extract<keyof FuncMap, string>>>, Extract<keyof FuncMap, string>> {
+  return {
+    __type: 'pikkuWorkflowGraph',
+    name: config.name,
+    description: config.description,
+    tags: config.tags,
+    wires: config.wires,
+    graph: graphBuilder(config.nodes, config.config as any),
+  }
+}
+
+/** Typed ref value */
+type TypedRef<T> = { $ref: string; path?: string } & { __phantomType?: T }
+
+/** Template string type - assignable to string fields */
+type TemplateString = {
+  $template: {
+    parts: string[]
+    expressions: Array<{ $ref: string; path?: string }>
+  }
+} & { __brand: 'TemplateString' }
+
+/**
+ * Creates a template string with variable interpolation
+ * Uses indexed placeholders $0, $1, etc. with refs array
+ *
+ * @example
+ * template('Hello $0, your order $1 is ready', [ref('trigger', 'name'), ref('step_0', 'orderId')])
+ */
+export function template(templateStr: string, refs: TypedRef<unknown>[]): TemplateString {
+  const parts: string[] = []
+  const expressions: Array<{ $ref: string; path?: string }> = []
+
+  // Parse template string: "Hello $0" -> parts: ["Hello ", ""], use refs[0] for expression
+  const regex = /$(d+)/g
+  let lastIndex = 0
+  let match
+
+  while ((match = regex.exec(templateStr)) !== null) {
+    // Add the part before this match
+    parts.push(templateStr.slice(lastIndex, match.index))
+
+    // Get the ref by index
+    const refIndex = parseInt(match[1]!, 10)
+    const refValue = refs[refIndex]
+    if (refValue) {
+      const expr: { $ref: string; path?: string } = { $ref: refValue.$ref }
+      if (refValue.path) {
+        expr.path = refValue.path
+      }
+      expressions.push(expr)
+    } else {
+      expressions.push({ $ref: 'unknown' })
+    }
+
+    lastIndex = regex.lastIndex
+  }
+
+  // Add the remaining part
+  parts.push(templateStr.slice(lastIndex))
+
+  return {
+    $template: { parts, expressions }
+  } as TemplateString
+}
+
+/** Map input type fields to allow TypedRef or TemplateString for any field */
+type InputWithRefs<T> = {
+  [K in keyof T]?: T[K] | TypedRef<T[K]> | TypedRef<unknown> | TemplateString
+}
+
+/** Get the input type for a node based on its RPC mapping */
+type NodeInputType<FuncMap extends Record<string, string>, K extends keyof FuncMap> =
+  FuncMap[K] extends keyof FlattenedRPCMap
+    ? InputWithRefs<FlattenedRPCMap[FuncMap[K]]['input']>
+    : Record<string, unknown>
+
+/** Get the output type keys for a node based on its RPC mapping */
+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
+
+/** Ref function type with path validation */
+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>
+}
+
+/** Template function type */
+type TemplateFunction = (templateStr: string, refs: TypedRef<unknown>[]) => TemplateString
+
+/** Type helper for node configuration */
+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 }
+
+// ============================================================================
+// Unified wireWorkflow
+// ============================================================================
+
+/** Workflow definition with DSL function */
+interface WorkflowDefinitionFunc {
+  /** Whether this workflow wiring is enabled (default: true) */
+  enabled?: boolean
+  /** Wire configurations for the workflow */
+  wires: {
+    http?: { route: string; method: HTTPMethod }
+    channel?: string
+    queue?: string
+  }
+  /** DSL workflow function */
+  func: PikkuFunctionConfig<any, any, 'workflow', PikkuFunctionWorkflow<any, any>>
+}
+
+/** Workflow definition with graph */
+interface WorkflowDefinitionGraph<T, NodeIds extends string = string> {
+  /** Whether this workflow wiring is enabled (default: true) */
+  enabled?: boolean
+  /** Graph workflow definition - wires are defined in the graph itself */
+  graph: PikkuWorkflowGraphResult<T, NodeIds>
+}
+
+/**
+ * Wire a workflow with wires
+ * Accepts either a DSL function (func) or a graph definition (graph)
+ *
+ * @example
+ * // DSL workflow
+ * wireWorkflow({
+ *   wires: { http: { route: '/start', method: 'post' } },
+ *   func: myWorkflowFunc,
+ * })
  *
- * @param workflow - Workflow definition with name, execution mode, and handler function
+ * @example
+ * // Graph workflow - wires are defined in the graph itself
+ * wireWorkflow({
+ *   enabled: true,  // default: true
+ *   graph: myGraphWorkflow,
+ * })
  */
-export const wireWorkflow = (workflow: WorkflowWiring) => {
-  wireWorkflowCore(workflow as any)
+export function wireWorkflow<T extends Record<string, GraphNodeConfig<Extract<keyof T, string>>>, NodeIds extends string = string>(
+  definition: WorkflowDefinitionFunc | WorkflowDefinitionGraph<T, NodeIds>
+): void {
+  coreWireWorkflow(definition as any)
 }

package/.pikku/workflow/pikku-workflow-wirings-meta.gen.ts

@@ -1,5 +1,9 @@
 /**
- * This file was generated by @pikku/cli@0.11.1
+ * This file was generated by @pikku/cli@0.11.3
  */
 import { pikkuState } from '@pikku/core'
-pikkuState('workflows', 'meta', {})
+import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'
+
+const workflowsMeta: SerializedWorkflowGraphs = {}
+
+pikkuState(null, 'workflows', 'meta', workflowsMeta)

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

@@ -1,4 +1,3 @@
 /**
- * This file was generated by @pikku/cli@0.11.1
+ * This file was generated by @pikku/cli@0.11.3
  */
-/* The files with an wireWorkflow function call */

package/CHANGELOG.md

@@ -1,4 +1,47 @@
-## 0.11.0
+## 0.11.3
+
+## 0.11.3
+
+### Patch Changes
+
+- 14a3dcd: fix: nextjs rpc route wasn't working
+- db9c7bf: Add workflow graph code generation and fix HTTP routes count
+- Updated dependencies [db9c7bf]
+- Updated dependencies [db9c7bf]
+  - @pikku/core@0.11.2
+  - @pikku/inspector@0.11.2
+
+### Features
+
+- f35e89da: Add workflow graph code generation
+  - Workflow graph serialization and type generation
+  - DSL to graph conversion for workflow metadata
+
+### Fixes
+
+- ddd87eaf: Make CreateWireServices type compatible with custom Config types
+- c42aad80: Correct HTTP routes count in CLI summary (was showing method count instead of route count)
+
+## 0.11.2
+
+### Patch Changes
+
+- 4b811db: chore: updating all dependencies
+- ce902b1: feat: serialize json files seperate to pikku meta state calls
+- e12a00c: feat: adding initialSession to PikkuWire which is correctly typed (undefined / not depending on function type)
+- ce902b1: feat: adding rpcName to rpc url so its nicer in network tabs
+- 4579434: breaking: changing the signature of functions
+- 28aeb7f: breaking: extract docs in the wiring meta
+- ce902b1: feat: adding in pikkuSimpleWorkflowFunc
+- 06e1a31: breaking: change session services to wire services
+- Updated dependencies [4b811db]
+- Updated dependencies [e12a00c]
+- Updated dependencies [4579434]
+- Updated dependencies [28aeb7f]
+- Updated dependencies [ce902b1]
+- Updated dependencies [06e1a31]
+  - @pikku/inspector@0.11.1
+  - @pikku/core@0.11.1
 
 ## 0.11.1
 

package/bin/pikku.ts

@@ -1,34 +1,10 @@
 #!/usr/bin/env node
 import { Command } from 'commander'
 import { createConfig, createSingletonServices } from '../src/services.js'
-import { PikkuRPCService } from '@pikku/core/rpc'
 import { LocalVariablesService } from '@pikku/core/services'
-import { existsSync } from 'fs'
-import { fileURLToPath } from 'url'
-import { dirname, join } from 'path'
+import { all as allCommand } from '../src/functions/commands/all.js'
+import { watch as watchCommand } from '../src/functions/commands/watch.js'
 
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-
-// Check if Pikku CLI is available
-const pikkuCliPath = join(__dirname, '../.pikku/cli/pikku-cli.gen.js')
-
-if (existsSync(pikkuCliPath)) {
-  try {
-    // Use the generated Pikku CLI
-    const { PikkuCLI } = await import(pikkuCliPath)
-    await PikkuCLI(process.argv.slice(2))
-    process.exit(0)
-  } catch (error) {
-    // If import fails, fall back to Commander.js
-    console.warn(
-      'Failed to load Pikku CLI, using fallback mode:',
-      error.message
-    )
-  }
-}
-
-// Fallback to Commander.js for initial setup
 // Import bootstrap if it exists
 try {
   await import('../.pikku/pikku-bootstrap.gen.js')
@@ -36,16 +12,14 @@ try {
   // Bootstrap doesn't exist yet, continue anyway
 }
 
-const action = async (command, cliConfig) => {
+const action = async (command: string, cliConfig: any) => {
   const config = await createConfig(new LocalVariablesService(), cliConfig)
   const services = await createSingletonServices(config)
-  const rpcWrapper = new PikkuRPCService()
-  const { rpc } = await rpcWrapper.injectRPCService(services, {}, false)
 
   if (command === 'watch') {
-    await rpc.invoke('watch', null)
+    await watchCommand.func(services)
   } else {
-    await rpc.invoke('all', null)
+    await allCommand.func(services)
   }
 }
 
@@ -60,7 +34,7 @@ const all = (program, name, description) => {
     )
     .option(
       '--session-services-factory-type',
-      'The type of your session services factory'
+      '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')