@pikku/cli 0.11.2 → 0.12.0

package/src/functions/wirings/cli/serialize-channel-cli-client.ts

@@ -1,184 +0,0 @@
-import { CLIProgramMeta, CLICommandMeta } from '@pikku/core/cli'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { Config } from '../../../../types/application-types.js'
-
-/**
- * Collect all unique renderer names from CLI metadata (populated by inspector)
- */
-export function collectRendererNames(programMeta: CLIProgramMeta): Set<string> {
-  const rendererNames = new Set<string>()
-
-  // Add program-level default renderer
-  if (programMeta.defaultRenderName) {
-    rendererNames.add(programMeta.defaultRenderName)
-  }
-
-  // Recursively collect renderer names from commands
-  function collectFromCommand(command: CLICommandMeta): void {
-    if (command.renderName) {
-      rendererNames.add(command.renderName)
-    }
-
-    // Recursively process subcommands
-    if (command.subcommands) {
-      for (const subCommand of Object.values(command.subcommands)) {
-        collectFromCommand(subCommand)
-      }
-    }
-  }
-
-  // Process all commands
-  for (const command of Object.values(programMeta.commands)) {
-    collectFromCommand(command)
-  }
-
-  return rendererNames
-}
-
-/**
- * Build a renderers map for CLI commands
- */
-function buildRenderersMap(programMeta: CLIProgramMeta): string {
-  const entries: string[] = []
-
-  // Build map entries for each command that has a renderer
-  function addCommandRenderer(command: CLICommandMeta, path: string[]): void {
-    const commandId = path.join('.')
-    if (command.renderName) {
-      entries.push(`    '${commandId}': ${command.renderName}`)
-    }
-
-    // Recursively process subcommands
-    if (command.subcommands) {
-      for (const [subName, subCommand] of Object.entries(command.subcommands)) {
-        addCommandRenderer(subCommand, [...path, subName])
-      }
-    }
-  }
-
-  // Process all commands
-  for (const [commandName, command] of Object.entries(programMeta.commands)) {
-    addCommandRenderer(command, [commandName])
-  }
-
-  if (entries.length === 0) {
-    return '{}'
-  }
-
-  return `{\n${entries.join(',\n')}\n  }`
-}
-
-/**
- * Serializes a CLI-over-Channel client bootstrap file
- * Similar to local CLI bootstrap but uses WebSocket connection
- */
-export function serializeChannelCLIClient(
-  programName: string,
-  programMeta: CLIProgramMeta,
-  clientFile: string,
-  config: Config,
-  cliBootstrapPath: string,
-  channelRoute?: string,
-  renderersMeta?: Record<string, any>
-): string {
-  const capitalizedName =
-    programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '')
-  const finalChannelRoute = channelRoute || `/cli/${programName}`
-
-  // Get relative import path to CLI bootstrap (for metadata)
-  const bootstrapImportPath = getFileImportRelativePath(
-    clientFile,
-    cliBootstrapPath,
-    config.packageMappings
-  )
-
-  // Collect all unique renderer names from CLI metadata (populated by inspector)
-  const rendererNames = collectRendererNames(programMeta)
-
-  // Generate renderer imports from their source files
-  let rendererImports = ''
-  if (rendererNames.size > 0 && renderersMeta) {
-    const importsByFile = new Map<string, string[]>()
-
-    for (const rendererName of rendererNames) {
-      const meta = renderersMeta[rendererName]
-      if (meta?.exportedName && meta?.filePath) {
-        const relativePath = getFileImportRelativePath(
-          clientFile,
-          meta.filePath,
-          config.packageMappings
-        )
-        if (!importsByFile.has(relativePath)) {
-          importsByFile.set(relativePath, [])
-        }
-        importsByFile.get(relativePath)!.push(meta.exportedName)
-      }
-    }
-
-    // Generate import statements
-    for (const [path, names] of importsByFile) {
-      rendererImports += `import { ${names.join(', ')} } from '${path}'\n`
-    }
-  }
-
-  // Build renderers map
-  const renderersMap = buildRenderersMap(programMeta)
-
-  // Determine default renderer
-  const defaultRendererCode = programMeta.defaultRenderName
-    ? `,\n    defaultRenderer: ${programMeta.defaultRenderName}`
-    : ''
-
-  return `
-import { executeCLIViaChannel } from '@pikku/core/cli/channel'
-import { CorePikkuWebsocket } from '@pikku/websocket'
-import '${bootstrapImportPath}'
-${rendererImports}
-/**
- * ${capitalizedName} CLI Client (via WebSocket Channel)
- * Executes CLI commands over a WebSocket connection
- */
-export async function ${capitalizedName}CLIClient(
-  ws: WebSocket,
-  args?: string[]
-): Promise<void> {
-  // Create Pikku WebSocket wrapper
-  const pikkuWS = new CorePikkuWebsocket(ws)
-
-  // Register renderers for CLI commands
-  const renderers = ${renderersMap}
-
-  await executeCLIViaChannel({
-    programName: '${programName}',
-    pikkuWS,
-    args,
-    renderers${defaultRendererCode},
-  })
-}
-
-// Export as default for easy importing
-export default ${capitalizedName}CLIClient
-
-// 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${finalChannelRoute}'
-
-  // 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
-  ${capitalizedName}CLIClient(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/src/functions/wirings/cli/serialize-channel-cli.ts

@@ -1,134 +0,0 @@
-import { CLIProgramMeta } from '@pikku/core/cli'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-/**
- * Serializes a wireChannel call from CLI metadata
- * This creates a WebSocket backend for all CLI commands
- */
-export function serializeChannelCLI(
-  programName: string,
-  programMeta: CLIProgramMeta,
-  channelFile: string,
-  functionFiles: Map<string, { path: string; exportedName: string }>,
-  packageMappings: Record<string, string>,
-  channelTypesFile: string,
-  functionTypesFile: string,
-  channelName?: string,
-  channelRoute?: string
-): string {
-  const finalChannelName = channelName || `${programName}-cli`
-  const finalChannelRoute = channelRoute || `/cli/${programName}`
-  // Flatten all commands into a single routing map
-  const commandMap: Record<
-    string,
-    { pikkuFuncName: string; importPath?: string }
-  > = {}
-
-  const collectCommands = (
-    commands: Record<string, any>,
-    path: string[] = []
-  ) => {
-    for (const [name, cmd] of Object.entries(commands)) {
-      const fullPath = [...path, name]
-      const commandKey = fullPath.join('.')
-
-      if (cmd.pikkuFuncName) {
-        commandMap[commandKey] = {
-          pikkuFuncName: cmd.pikkuFuncName,
-        }
-      }
-
-      // Recursively process subcommands
-      if (cmd.subcommands) {
-        collectCommands(cmd.subcommands, fullPath)
-      }
-    }
-  }
-
-  collectCommands(programMeta.commands)
-
-  // Generate imports from function file locations
-  const funcNames = [
-    ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncName)),
-  ]
-  const imports = funcNames
-    .map((pikkuFuncName) => {
-      const fileInfo = functionFiles.get(pikkuFuncName)
-      if (!fileInfo) {
-        throw new Error(`Function not found in files map: ${pikkuFuncName}`)
-      }
-
-      const importPath = getFileImportRelativePath(
-        channelFile,
-        fileInfo.path,
-        packageMappings
-      )
-      return `import { ${fileInfo.exportedName} } from '${importPath}'`
-    })
-    .join('\n')
-
-  // Get relative path to channel types file
-  const channelTypesPath = getFileImportRelativePath(
-    channelFile,
-    channelTypesFile,
-    packageMappings
-  )
-
-  // Get relative path to function types file
-  const functionTypesPath = getFileImportRelativePath(
-    channelFile,
-    functionTypesFile,
-    packageMappings
-  )
-
-  return `/**
- * WebSocket channel backend for '${programName}' CLI commands
- */
-import { wireChannel } from '${channelTypesPath}'
-import { pikkuMiddleware } from '${functionTypesPath}'
-${imports}
-
-// 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: '${finalChannelName}',
-  route: '${finalChannelRoute}',
-  auth: false,
-  onMessageWiring: {
-    command: {
-${Object.entries(commandMap)
-  .map(
-    ([commandKey, { pikkuFuncName }]) =>
-      `      '${commandKey}': {
-        func: ${pikkuFuncName},
-        middleware: [cliCloseOnComplete],
-      }`
-  )
-  .join(',\n')}
-    }
-  },
-  tags: ['cli', '${programName}']
-})
-`
-}

package/src/functions/wirings/cli/serialize-cli-types.ts

@@ -1,101 +0,0 @@
-/**
- * Generates type definitions for CLI wirings
- */
-export const serializeCLITypes = (
-  functionTypesImportPath: string,
-  userSessionTypeImport: string,
-  userSessionTypeName: string,
-  singletonServicesTypeImport: string,
-  singletonServicesTypeName: string
-) => {
-  return `/**
-
- * CLI-specific type definitions for tree-shaking optimization
- */
-
-import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core/cli'
-import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
-${userSessionTypeImport}
-${singletonServicesTypeImport}
-
-${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
-${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
-
-/**
- * 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/src/functions/wirings/cli/serialize-local-cli-bootstrap.ts

@@ -1,80 +0,0 @@
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { Config } from '../../../../types/application-types.js'
-
-/**
- * Serializes the local (in-program) CLI bootstrap code
- */
-export function serializeLocalCLIBootstrap(
-  programName: string,
-  _programMeta: any,
-  bootstrapFile: string,
-  config: Config,
-  pikkuConfigFactory: { file: string; variable: string },
-  singletonServicesFactory: { file: string; variable: string },
-  wireServicesFactory: { file: string; variable: string }
-): string {
-  const capitalizedName =
-    programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '')
-
-  // Get relative import paths
-  const pikkuConfigPath = getFileImportRelativePath(
-    bootstrapFile,
-    pikkuConfigFactory.file,
-    config.packageMappings
-  )
-  const singletonServicesPath = getFileImportRelativePath(
-    bootstrapFile,
-    singletonServicesFactory.file,
-    config.packageMappings
-  )
-  const wireServicesPath = getFileImportRelativePath(
-    bootstrapFile,
-    wireServicesFactory.file,
-    config.packageMappings
-  )
-  const cliBootstrapPath = getFileImportRelativePath(
-    bootstrapFile,
-    config.bootstrapFile,
-    config.packageMappings
-  )
-
-  return `
-import { executeCLI, CLIError } from '@pikku/core/cli'
-import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
-import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
-import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'
-import '${cliBootstrapPath}'
-
-/**
- * ${capitalizedName} CLI function
- * Handles command line arguments and executes the appropriate function
- */
-export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
-  try {
-    await executeCLI({
-      programName: '${programName}',
-      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 ${capitalizedName}CLI
-
-// For direct execution (if this file is run directly)
-if (import.meta.url === \`file://\${process.argv[1]}\`) {
-  ${capitalizedName}CLI(process.argv.slice(2)).catch(error => {
-    console.error('Fatal error:', error.message)
-    process.exit(1)
-  })
-}
-`
-}

package/src/functions/wirings/fetch/index.ts

@@ -1,36 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-
-export const pikkuFetch: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const { fetchFile, httpMapDeclarationFile, packageMappings } = config
-
-    // If fetchFile is not set, clean up any existing file and return
-    if (!fetchFile) {
-      logger.info({
-        message:
-          "Skipping generating fetch wrapper since fetchFile isn't set in the pikku config.",
-        type: 'skip',
-      })
-      return
-    }
-
-    const routesMapDeclarationPath = getFileImportRelativePath(
-      fetchFile,
-      httpMapDeclarationFile,
-      packageMappings
-    )
-
-    const content = [serializeFetchWrapper(routesMapDeclarationPath)]
-    await writeFileInDir(logger, fetchFile, content.join('\n'))
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating fetch wrapper',
-      commandEnd: 'Generated fetch wrapper',
-    }),
-  ],
-})

package/src/functions/wirings/functions/pikku-command-function-types-split.ts

@@ -1,60 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { checkRequiredTypes } from '../../../utils/check-required-types.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeFunctionTypes } from './serialize-function-types.js'
-
-export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const {
-      functionTypesFile,
-      packageMappings,
-      rpcInternalMapDeclarationFile,
-      servicesFile,
-    } = config
-
-    // Check for required types
-    checkRequiredTypes(visitState.filesAndMethodsErrors, {
-      userSessionType: true,
-      wireServiceType: true,
-      singletonServicesType: true,
-    })
-
-    const {
-      userSessionType,
-      wireServicesType,
-      singletonServicesType,
-      pikkuConfigType,
-    } = visitState.filesAndMethods
-
-    if (!userSessionType || !wireServicesType || !singletonServicesType) {
-      throw new Error('Required types not found')
-    }
-
-    const configTypeImport = pikkuConfigType
-      ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
-      : '// Config type not found, will use fallback'
-
-    const content = serializeFunctionTypes(
-      `import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`,
-      userSessionType.type,
-      `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`,
-      singletonServicesType.type,
-      `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`,
-      wireServicesType.type,
-      `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`,
-      `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`,
-      configTypeImport
-    )
-
-    await writeFileInDir(logger, functionTypesFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating function types',
-      commandEnd: 'Created function types',
-    }),
-  ],
-})

package/src/functions/wirings/functions/pikku-command-function-types.ts

@@ -1,43 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js'
-
-export const pikkuFunctionTypes: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const {
-      typesDeclarationFile: typesFile,
-      packageMappings,
-      functionTypesFile,
-      httpTypesFile,
-      channelsTypesFile,
-      schedulersTypesFile,
-      queueTypesFile,
-      mcpTypesFile,
-      cliTypesFile,
-    } = config
-
-    const content = serializePikkuTypesHub(
-      getFileImportRelativePath(typesFile, functionTypesFile, packageMappings),
-      getFileImportRelativePath(typesFile, httpTypesFile, packageMappings),
-      getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings),
-      getFileImportRelativePath(
-        typesFile,
-        schedulersTypesFile,
-        packageMappings
-      ),
-      getFileImportRelativePath(typesFile, queueTypesFile, packageMappings),
-      getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings),
-      getFileImportRelativePath(typesFile, cliTypesFile, packageMappings)
-    )
-
-    await writeFileInDir(logger, typesFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating api types hub',
-      commandEnd: 'Created api types hub',
-    }),
-  ],
-})