@pikku/cli 0.11.3 → 0.12.1

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

@@ -1,148 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.3
- */
-/**
-
- * Channel-specific type definitions for tree-shaking optimization
- */
-
-import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
-import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '../function/pikku-function-types.gen.js'
-import type { ZodLike, CorePermissionGroup } from '@pikku/core'
-
-/**
- * Helper type to infer the output type from a Zod schema
- */
-type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never
-
-/**
- * Type definition for WebSocket channels with typed data exchange.
- * Supports connection, disconnection, and message handling.
- * Accepts both session-based (PikkuFunction) and sessionless (PikkuFunctionSessionless) functions.
- *
- * @template ChannelData - Type of data exchanged through the channel
- * @template Channel - String literal type for the channel name
- */
-type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
-  ChannelData,
-  Channel,
-  PikkuFunctionConfig<void, any, 'channel' | 'session' | 'rpc'>,
-  PikkuFunctionConfig<void, void, 'channel' | 'session' | 'rpc'>,
-  PikkuFunctionConfig<any, any, 'channel' | 'session' | 'rpc'>,
-  PikkuPermission,
-  PikkuMiddleware
->
-
-/**
- * Creates a function that handles WebSocket channel connections.
- * Called when a client connects to a channel.
- *
- * @template Out - Output type for connection response
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- */
-export const pikkuChannelConnectionFunc = <Out = unknown>(
-  func:
-    | PikkuFunctionSessionless<void, Out, 'channel' | 'session' | 'rpc'>
-    | PikkuFunctionConfig<void, Out, 'channel' | 'session' | 'rpc'>
-) => {
-  return typeof func === 'function' ? { func } : func
-}
-
-/**
- * Creates a function that handles WebSocket channel disconnections.
- * Called when a client disconnects from a channel.
- *
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- */
-export const pikkuChannelDisconnectionFunc = (
-  func:
-    | PikkuFunctionSessionless<void, void, 'channel'>
-    | PikkuFunctionConfig<void, void, 'channel' | 'session' | 'rpc'>
-) => {
-  return typeof func === 'function' ? { func } : func
-}
-
-/**
- * Configuration object for channel functions with Zod schema validation.
- */
-type PikkuChannelFuncConfigWithSchema<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
-> = {
-  name?: string
-  tags?: string[]
-  expose?: boolean
-  internal?: boolean
-  func: PikkuFunctionSessionless<
-    InferZodOutput<InputSchema>,
-    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
-    'channel' | 'session' | 'rpc'
-  >
-  auth?: boolean
-  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
-  middleware?: PikkuMiddleware[]
-  input: InputSchema
-  output?: OutputSchema
-}
-
-/**
- * Creates a function that handles WebSocket channel messages.
- * Called when a message is received on a channel.
- *
- * Supports two patterns:
- * 1. Generic types: `pikkuChannelFunc<Input, Output>({ func: ... })`
- * 2. Zod schemas: `pikkuChannelFunc({ input: z.object(...), func: ... })`
- *
- * @template In - Input type for channel messages (inferred from schema if provided)
- * @template Out - Output type for channel responses (inferred from schema if provided)
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- *
- * @example
- * ```typescript
- * // Pattern 1: Using generic types
- * const handleMessage = pikkuChannelFunc<{text: string}, {received: boolean}>({
- *   func: async (_services, { text }) => ({ received: true })
- * })
- *
- * // Pattern 2: Using Zod schemas
- * const messageInput = z.object({ text: z.string() })
- * const messageOutput = z.object({ received: z.boolean() })
- *
- * const handleMessage = pikkuChannelFunc({
- *   input: messageInput,
- *   output: messageOutput,
- *   func: async (_services, { text }) => ({ received: true })
- * })
- * ```
- */
-export function pikkuChannelFunc<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
->(
-  config: PikkuChannelFuncConfigWithSchema<InputSchema, OutputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'channel' | 'session' | 'rpc'>
-export function pikkuChannelFunc<In, Out = unknown>(
-  func:
-    | PikkuFunctionSessionless<In, Out, 'channel' | 'session' | 'rpc'>
-    | PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
-): PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
-export function pikkuChannelFunc(func: any) {
-  return typeof func === 'function' ? { func } : func
-}
-
-/**
- * Registers a WebSocket channel with the Pikku framework.
- *
- * @template ChannelData - Type of data associated with the channel
- * @template Channel - String literal type for the channel name
- * @param channel - Channel definition with connection, disconnection, and message handlers
- */
-export const wireChannel = <ChannelData, Channel extends string>(
-  channel: ChannelWiring<ChannelData, Channel> & AssertHTTPWiringParams<ChannelData, Channel>
-) => {
-  wireChannelCore(channel as any) // TODO
-}

package/.pikku/channel/pikku-channels-map.gen.d.ts

@@ -1,47 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.3
- */
-/**
- * This provides the structure needed for TypeScript to be aware of channels
- */
-
-
-
-export type PikkuSchemasOutput = false | true
-export type PikkuFunctionsOutput = false | true
-export type PikkuMiddlewareOutput = false | true
-export type PikkuPermissionsOutput = false | true
-export type PikkuRPCOutput = false | true
-export type PikkuPublicRPCOutput = false | true
-export type PikkuHTTPOutput = false | true
-export type PikkuSchedulerOutput = false | true
-export type PikkuWorkflowOutput = false | true
-export type PikkuRemoteRPCOutput = false | true
-export type PikkuQueueOutput = false | true
-export type PikkuChannelsOutput = false | true
-export type PikkuMCPOutput = false | true
-export type PikkuCLIOutput = false | true
-export type PikkuPackageOutput = false | true
-export type PikkuForgeNodesOutput = false | true
-
-interface ChannelHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-export type ChannelsMap = {
-};
-
-export type ChannelDefaultHandlerOf<Channel extends keyof ChannelsMap> =
-    ChannelsMap[Channel]['defaultMessage'] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-
-export type ChannelWiringHandlerOf<
-    Channel extends keyof ChannelsMap, 
-    Route extends keyof ChannelsMap[Channel]['routes'], 
-    Method extends keyof ChannelsMap[Channel]['routes'][Route],
-> =
-    ChannelsMap[Channel]['routes'][Route][Method] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;

package/.pikku/channel/pikku-channels-meta.gen.json

@@ -1 +0,0 @@
-{}

package/.pikku/channel/pikku-channels-meta.gen.ts

@@ -1,7 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.3
- */
-import { pikkuState } from '@pikku/core'
-import type { ChannelsMeta } from '@pikku/core/channel'
-import metaData from './pikku-channels-meta.gen.json' with { type: 'json' }
-pikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)

package/.pikku/channel/pikku-channels.gen.ts

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

package/.pikku/cli/pikku-cli-channel.ts

@@ -1,92 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.3
- */
-/**
- * WebSocket channel backend for 'pikku' CLI commands
- */
-import { wireChannel } from '../channel/pikku-channel-types.gen.js'
-import { pikkuMiddleware } from '../function/pikku-function-types.gen.js'
-import { all } from '../../src/functions/commands/all.js'
-import { bootstrap } from '../../src/functions/commands/bootstrap.js'
-import { watch } from '../../src/functions/commands/watch.js'
-import { pikkuSchemas } from '../../src/functions/wirings/functions/schemas.js'
-import { pikkuFetch } from '../../src/functions/wirings/fetch/index.js'
-import { pikkuWebSocketTyped } from '../../src/functions/wirings/channels/pikku-command-websocket-typed.js'
-import { pikkuRPCClient } from '../../src/functions/wirings/rpc/pikku-command-rpc-client.js'
-import { pikkuQueueService } from '../../src/functions/wirings/queue/pikku-command-queue-service.js'
-import { pikkuOpenAPI } from '../../src/functions/wirings/http/pikku-command-openapi.js'
-import { pikkuNext } from '../../src/functions/runtimes/nextjs/pikku-command-nextjs.js'
-
-// Middleware to close the channel after CLI command completes
-const cliCloseOnComplete = pikkuMiddleware(async (_services, { channel }, next) => {
-  const closeChannel = () => {
-    setTimeout(async () => {
-      try {
-        // This gives time for the response to be sent before closing
-        await channel?.close()
-      } catch (err) {
-        // Ignore errors on close
-      }
-    }, 200)
-  }
-  
-  try {
-    const result = await next()
-    closeChannel()
-    return result
-  } catch (error) {
-    closeChannel()
-    throw error
-  }
-})
-
-wireChannel({
-  name: 'pikku-cli',
-  route: '/cli/pikku',
-  auth: false,
-  onMessageWiring: {
-    command: {
-      'all': {
-        func: all,
-        middleware: [cliCloseOnComplete],
-      },
-      'bootstrap': {
-        func: bootstrap,
-        middleware: [cliCloseOnComplete],
-      },
-      'watch': {
-        func: watch,
-        middleware: [cliCloseOnComplete],
-      },
-      'schemas': {
-        func: pikkuSchemas,
-        middleware: [cliCloseOnComplete],
-      },
-      'fetch': {
-        func: pikkuFetch,
-        middleware: [cliCloseOnComplete],
-      },
-      'websocket': {
-        func: pikkuWebSocketTyped,
-        middleware: [cliCloseOnComplete],
-      },
-      'rpc': {
-        func: pikkuRPCClient,
-        middleware: [cliCloseOnComplete],
-      },
-      'queue-service': {
-        func: pikkuQueueService,
-        middleware: [cliCloseOnComplete],
-      },
-      'openapi': {
-        func: pikkuOpenAPI,
-        middleware: [cliCloseOnComplete],
-      },
-      'nextjs': {
-        func: pikkuNext,
-        middleware: [cliCloseOnComplete],
-      }
-    }
-  },
-  tags: ['cli', 'pikku']
-})

package/.pikku/cli/pikku-cli-client.gen.ts

@@ -1,54 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.3
- */
-
-import { executeCLIViaChannel } from '@pikku/core/cli/channel'
-import { CorePikkuWebsocket } from '@pikku/websocket'
-import '../pikku-bootstrap.gen.js'
-
-/**
- * Pikku CLI Client (via WebSocket Channel)
- * Executes CLI commands over a WebSocket connection
- */
-export async function PikkuCLIClient(
-  ws: WebSocket,
-  args?: string[]
-): Promise<void> {
-  // Create Pikku WebSocket wrapper
-  const pikkuWS = new CorePikkuWebsocket(ws)
-
-  // Register renderers for CLI commands
-  const renderers = {}
-
-  await executeCLIViaChannel({
-    programName: 'pikku',
-    pikkuWS,
-    args,
-    renderers,
-  })
-}
-
-// Export as default for easy importing
-export default PikkuCLIClient
-
-// For direct execution (if this file is run directly)
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const url = process.env.PIKKU_WS_URL || 'ws://localhost:4002/cli/pikku'
-
-  // Create WebSocket instance
-  let WebSocketImpl: any
-  if (typeof WebSocket !== 'undefined') {
-    WebSocketImpl = WebSocket
-  } else {
-    // Node.js environment - dynamically import 'ws'
-    const wsModule = await import('ws')
-    WebSocketImpl = wsModule.default
-  }
-
-  const ws = new WebSocketImpl(url) as WebSocket
-  PikkuCLIClient(ws, process.argv.slice(2)).catch(error => {
-    console.error('Fatal channel CLI error:', error)
-    // TODO: We get an error code even when it exists cleanly, investigate
-    // process.exit(1)
-  })
-}

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

@@ -1,92 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.3
- */
-/**
-
- * CLI-specific type definitions for tree-shaking optimization
- */
-
-import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core/cli'
-import type { PikkuFunctionConfig, PikkuMiddleware } from '../function/pikku-function-types.gen.js'
-import type { UserSession } from '../../types/application-types.d.js'
-import type { SingletonServices } from '../../types/application-types.d.js'
-
-
-type Session = UserSession
-
-/**
- * Type-safe CLI renderer definition that can access your application's services.
- * Use this to define custom renderers for CLI command output.
- *
- * @template Data - The output data type from the CLI command
- * @template RequiredServices - The services required for this renderer
- */
-type PikkuCLIRender<Data, RequiredServices extends SingletonServices = SingletonServices> = CorePikkuCLIRender<Data, RequiredServices, Session>
-
-/**
- * Creates a type-safe CLI renderer with access to your application's singleton services.
- * The renderer receives the full singleton services and output data to format and display results.
- *
- * @template Data - The output data type from the CLI command
- * @template RequiredServices - The minimum services required for type checking (defaults to SingletonServices)
- * @param render - Function that receives singleton services and data to render output
- * @returns A CLI renderer configuration
- *
- * @example
- * ```typescript
- * const myRenderer = pikkuCLIRender<MyData>(({ logger }, data) => {
- *   logger.info(data.message)
- * })
- * ```
- */
-export const pikkuCLIRender = <Data, RequiredServices extends SingletonServices = SingletonServices>(
-  render: (services: SingletonServices, data: Data) => void | Promise<void>
-): PikkuCLIRender<Data, RequiredServices> => {
-  return render as any
-}
-
-/**
- * CLI command configuration with project-specific types.
- * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.
- */
-type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out, 'cli' | 'rpc' | 'session'>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
-
-/**
- * Type definition for CLI applications with commands and global options.
- *
- * @template Commands - Type describing the command structure
- * @template GlobalOptions - Type for global CLI options
- */
-type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions> = CoreCLI<Commands, GlobalOptions, PikkuMiddleware, PikkuCLIRender<any>>
-
-/**
- * Registers a CLI application with the Pikku framework.
- * Creates command-line interfaces with type-safe commands and options.
- *
- * @template Commands - Type describing the command structure
- * @template GlobalOptions - Type for global CLI options
- * @param cli - CLI definition with program name, commands, and global options
- */
-export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions>(
-  cli: CLIWiring<Commands, GlobalOptions>
-) => {
-  wireCLICore(cli as any)
-}
-
-/**
- * Creates a CLI command definition with automatic option inference from the function's input type.
- * This allows TypeScript to automatically derive CLI options from the function signature.
- *
- * @template FuncConfig - The Pikku function config type
- * @template Params - The parameters string literal type
- * @param config - CLI command configuration
- * @returns CLI command configuration with inferred types
- */
-export const pikkuCLICommand = <
-  FuncConfig extends PikkuFunctionConfig<any, any, 'cli' | 'rpc' | 'session'>,
-  Params extends string
->(
-  config: CLICommandConfig<FuncConfig, any, any, Params>
-): CoreCLICommandConfig<FuncConfig, PikkuMiddleware, PikkuCLIRender<any>, string> => {
-  return config as any
-}

package/.pikku/cli/pikku-cli-wirings-meta.gen.json

@@ -1,147 +0,0 @@
-{
-  "programs": {
-    "pikku": {
-      "program": "pikku",
-      "commands": {
-        "all": {
-          "pikkuFuncName": "all",
-          "positionals": [],
-          "options": {
-            "tags": {
-              "description": "Filter functions by tags (comma-separated)",
-              "short": "t"
-            },
-            "types": {
-              "description": "Filter functions by types (comma-separated)"
-            },
-            "directories": {
-              "description": "Filter functions by directories (comma-separated)",
-              "short": "d"
-            },
-            "httpMethods": {
-              "description": "Filter HTTP routes by methods (comma-separated)"
-            },
-            "httpRoutes": {
-              "description": "Filter HTTP routes by route patterns (comma-separated)"
-            },
-            "names": {
-              "description": "Filter functions by name patterns (supports wildcards)",
-              "short": "n"
-            }
-          },
-          "description": "Generate all Pikku files (types, schemas, wirings, etc.)",
-          "isDefault": true
-        },
-        "bootstrap": {
-          "pikkuFuncName": "bootstrap",
-          "positionals": [],
-          "options": {},
-          "description": "Generate only type files (setup phase only)"
-        },
-        "watch": {
-          "pikkuFuncName": "watch",
-          "positionals": [],
-          "options": {},
-          "description": "Watch for file changes and regenerate automatically"
-        },
-        "schemas": {
-          "pikkuFuncName": "pikkuSchemas",
-          "positionals": [],
-          "options": {},
-          "description": "Generate JSON schemas for function input/output types"
-        },
-        "fetch": {
-          "pikkuFuncName": "pikkuFetch",
-          "positionals": [],
-          "options": {},
-          "description": "Generate type-safe HTTP fetch client"
-        },
-        "websocket": {
-          "pikkuFuncName": "pikkuWebSocketTyped",
-          "positionals": [],
-          "options": {},
-          "description": "Generate type-safe WebSocket client"
-        },
-        "rpc": {
-          "pikkuFuncName": "pikkuRPCClient",
-          "positionals": [],
-          "options": {},
-          "description": "Generate RPC client wrappers"
-        },
-        "queue-service": {
-          "pikkuFuncName": "pikkuQueueService",
-          "positionals": [],
-          "options": {},
-          "description": "Generate queue service wrapper"
-        },
-        "openapi": {
-          "pikkuFuncName": "pikkuOpenAPI",
-          "positionals": [],
-          "options": {},
-          "description": "Generate OpenAPI specification from HTTP routes"
-        },
-        "nextjs": {
-          "pikkuFuncName": "pikkuNext",
-          "positionals": [],
-          "options": {},
-          "description": "Generate Next.js backend and HTTP wrappers"
-        }
-      },
-      "options": {
-        "config": {
-          "description": "Path to pikku.config.json file",
-          "short": "c"
-        },
-        "logLevel": {
-          "description": "Set log level",
-          "short": "l",
-          "choices": [
-            "trace",
-            "debug",
-            "info",
-            "warn",
-            "error",
-            "critical"
-          ]
-        },
-        "userSessionType": {
-          "description": "Specify which UserSession type to use (when multiple exist)"
-        },
-        "singletonServicesFactoryType": {
-          "description": "Specify which singleton services factory to use"
-        },
-        "wireServicesFactoryType": {
-          "description": "Specify which wire services factory to use"
-        },
-        "stateOutput": {
-          "description": "Save inspector state to JSON file for reuse"
-        },
-        "stateInput": {
-          "description": "Load inspector state from JSON file (skips inspection)"
-        }
-      }
-    }
-  },
-  "renderers": {
-    "defaultCLIRenderer": {
-      "name": "defaultCLIRenderer",
-      "exportedName": "defaultCLIRenderer",
-      "services": {
-        "optimized": true,
-        "services": [
-          "logger",
-          "getInspectorState",
-          "schema",
-          "jwt",
-          "config",
-          "variables",
-          "secrets",
-          "workflowService",
-          "queueService",
-          "schedulerService"
-        ]
-      },
-      "filePath": "/home/runner/work/pikku/pikku/packages/cli/src/services.ts"
-    }
-  }
-}

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

@@ -1,7 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.3
- */
-import { pikkuState } from '@pikku/core'
-import { CLIMeta } from '@pikku/core/cli'
-import metaData from './pikku-cli-wirings-meta.gen.json' with { type: 'json' }
-pikkuState(null, 'cli', 'meta', metaData as CLIMeta)

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

@@ -1,6 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.3
- */
-/* The files with an wireCLI function call */
-import '../../src/cli.wiring.js'
-import '../../src/services.js'

package/.pikku/cli/pikku-cli.gen.ts

@@ -1,41 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.3
- */
-
-import { executeCLI, CLIError } from '@pikku/core/cli'
-import { createConfig as createConfig } from '../../src/services.js'
-import { createSingletonServices as createSingletonServices } from '../../src/services.js'
-import { createWireServices as createWireServices } from '../../src/services.js'
-import '../pikku-bootstrap.gen.js'
-
-/**
- * Pikku CLI function
- * Handles command line arguments and executes the appropriate function
- */
-export async function PikkuCLI(args: string[]): Promise<void> {
-  try {
-    await executeCLI({
-      programName: 'pikku',
-      args: args || process.argv.slice(2),
-      createConfig,
-      createSingletonServices,
-      createWireServices,
-    })
-  } catch (error) {
-    if (error instanceof CLIError) {
-      process.exit(error.exitCode)
-    }
-    throw error
-  }
-}
-
-// Export as default for easy importing
-export default PikkuCLI
-
-// For direct execution (if this file is run directly)
-if (import.meta.url === `file://${process.argv[1]}`) {
-  PikkuCLI(process.argv.slice(2)).catch(error => {
-    console.error('Fatal error:', error.message)
-    process.exit(1)
-  })
-}