@pikku/cli 0.11.2 → 0.12.0

package/src/functions/wirings/workflow/serialize-workflow-map.ts

@@ -1,123 +0,0 @@
-import type { WorkflowsMeta } from '@pikku/core/workflow'
-import { serializeImportMap } from '../../../utils/serialize-import-map.js'
-import { TypesMap } from '@pikku/inspector'
-import { FunctionsMeta } from '@pikku/core'
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
-
-export const serializeWorkflowMap = (
-  relativeToPath: string,
-  packageMappings: Record<string, string>,
-  typesMap: TypesMap,
-  functionsMeta: FunctionsMeta,
-  workflowsMeta: WorkflowsMeta
-) => {
-  const requiredTypes = new Set<string>()
-  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
-  const serializedWorkflows = generateWorkflows(
-    workflowsMeta,
-    functionsMeta,
-    typesMap,
-    requiredTypes
-  )
-
-  const serializedImportMap = serializeImportMap(
-    relativeToPath,
-    packageMappings,
-    typesMap,
-    requiredTypes
-  )
-
-  return `/**
- * This provides the structure needed for TypeScript to be aware of workflows and their input/output types
- */
-
-${serializedImportMap}
-${serializedCustomTypes}
-
-interface WorkflowHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedWorkflows}
-
-/**
- * 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>;
-}
-  `
-}
-
-function generateWorkflows(
-  workflowsMeta: WorkflowsMeta,
-  functionsMeta: FunctionsMeta,
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  // Initialize an object to collect workflows
-  const workflowsObj: Record<
-    string,
-    { inputType: string; outputType: string }
-  > = {}
-
-  // Iterate through workflow metadata
-  for (const [workflowName, { pikkuFuncName }] of Object.entries(
-    workflowsMeta
-  )) {
-    const functionMeta = functionsMeta[pikkuFuncName]
-    if (!functionMeta) {
-      throw new Error(
-        `Function ${workflowName} not found in functionsMeta. Please check your configuration.`
-      )
-    }
-
-    const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
-    const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
-
-    // Store the input and output types for WorkflowHandler
-    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'void'
-    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'void'
-
-    requiredTypes.add(inputType)
-    requiredTypes.add(outputType)
-
-    // Add workflow entry
-    workflowsObj[workflowName] = {
-      inputType,
-      outputType,
-    }
-  }
-
-  // Build the Workflows object as a string
-  let workflowsStr = 'export type WorkflowMap = {\n'
-
-  for (const [workflowName, handler] of Object.entries(workflowsObj)) {
-    workflowsStr += `  readonly '${workflowName}': WorkflowHandler<${handler.inputType}, ${handler.outputType}>,\n`
-  }
-
-  workflowsStr += '};\n'
-
-  return workflowsStr
-}

package/src/functions/wirings/workflow/serialize-workflow-meta.ts

@@ -1,33 +0,0 @@
-import { WorkflowsMeta } from '@pikku/core/workflow'
-
-export const serializeWorkflowMeta = (workflowsMeta: WorkflowsMeta) => {
-  return workflowsMeta
-}
-
-export const serializeWorkflowMetaTS = (
-  workflowsMeta: WorkflowsMeta,
-  jsonImportPath: string,
-  supportsImportAttributes: boolean
-) => {
-  const importStatement = supportsImportAttributes
-    ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-    : `import metaData from '${jsonImportPath}'`
-
-  const serializedOutput: string[] = []
-  serializedOutput.push("import { pikkuState } from '@pikku/core'")
-  serializedOutput.push("import { WorkflowsMeta } from '@pikku/core/workflow'")
-  serializedOutput.push(importStatement)
-  serializedOutput.push('')
-  serializedOutput.push(
-    "pikkuState('workflows', 'meta', metaData as WorkflowsMeta)"
-  )
-  serializedOutput.push('')
-
-  const workflowsMetaValues = Object.values(workflowsMeta)
-  if (workflowsMetaValues.length > 0) {
-    serializedOutput.push(
-      `export type WorkflowNames = '${workflowsMetaValues.map((w) => w.workflowName).join("' | '")}'`
-    )
-  }
-  return serializedOutput.join('\n')
-}

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

@@ -1,103 +0,0 @@
-/**
- * Generates type definitions for workflow wirings
- */
-export const serializeWorkflowTypes = (
-  functionTypesImportPath: string,
-  rpcMapImportPath: string
-) => {
-  return `/**
- * Workflow-specific type definitions for tree-shaking optimization
- */
-
-import { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow'
-import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '${functionTypesImportPath}'
-import type { RPCMap } from '${rpcMapImportPath}'
-
-/**
- * Typed workflow wire with RPC awareness
- * Provides type-safe workflow.do() for RPC steps
- */
-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 const pikkuWorkflowFunc = <In, Out = unknown>(
-  func:
-    | PikkuFunctionWorkflow<In, Out>
-    | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
-) => {
-  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 = <In, Out = unknown>(
-  func:
-    | PikkuFunctionWorkflow<In, Out>
-    | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
-) => {
-  return typeof func === 'function' ? { func } : func
-}
-
-`
-}

package/src/functions/wirings/workflow/serialize-workflow-wirings.ts

@@ -1,47 +0,0 @@
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-/**
- * Generate workflow registration wirings
- * Imports all workflow functions and calls addWorkflow for each
- */
-export const serializeWorkflowWirings = (
-  outputPath: string,
-  workflowFiles: Map<string, { path: string; exportedName: string }>,
-  packageMappings: Record<string, string> = {}
-) => {
-  const imports: string[] = []
-  const registrations: string[] = []
-
-  // Sort by pikkuFuncName for consistent output
-  const sortedWorkflows = Array.from(workflowFiles.entries()).sort((a, b) =>
-    a[0].localeCompare(b[0])
-  )
-
-  // Generate imports
-  for (const [, { path, exportedName }] of sortedWorkflows) {
-    const importPath = getFileImportRelativePath(
-      outputPath,
-      path,
-      packageMappings
-    )
-    imports.push(`import { ${exportedName} } from '${importPath}'`)
-  }
-
-  // Generate addWorkflow calls
-  for (const [pikkuFuncName, { exportedName }] of sortedWorkflows) {
-    registrations.push(`addWorkflow('${pikkuFuncName}', ${exportedName})`)
-  }
-
-  // Only import addWorkflow if there are workflows to register
-  const addWorkflowImport =
-    sortedWorkflows.length > 0
-      ? `import { addWorkflow } from '@pikku/core/workflow'\n\n`
-      : ''
-
-  return `/**
- * Auto-generated workflow registrations
- * Do not edit manually - regenerate with 'npx pikku'
- */
-${addWorkflowImport}${imports.join('\n')}${imports.length > 0 ? '\n\n' : ''}${registrations.join('\n')}
-`
-}

package/src/functions/wirings/workflow/serialize-workflow-workers.ts

@@ -1,60 +0,0 @@
-/**
- * Generate queue workers and RPC functions for workflow steps and orchestrator
- */
-export const serializeWorkflowWorkers = (pathToPikkuTypes: string) => {
-  return `/**
- * Auto-generated workflow queue workers and RPC functions
- * Do not edit manually - regenerate with 'npx pikku'
- */
-import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
-
-/**
- * Worker input types for generated queue workers
- */
-export type WorkflowStepInput = {
-  runId: string
-  stepName: string
-  rpcName: string
-  data: any
-}
-
-export const pikkuWorkflowWorker = pikkuSessionlessFunc<
-  WorkflowStepInput,
-  void
->({
-  func: async ({ workflowService }, { runId, stepName, rpcName, data }, { rpc }) => {
-    await workflowService!.executeWorkflowStep(runId, stepName, rpcName, data, rpc)
-  }
-})
-
-export const pikkuWorkflowOrchestrator = pikkuSessionlessFunc<
-  { runId: string },
-  void
->({
-  func: async ({ workflowService }, { runId }, { rpc }) => {
-    await workflowService!.orchestrateWorkflow(runId, rpc)
-  }
-})
-
-export const pikkuWorkflowSleeper = pikkuSessionlessFunc<
-  { runId: string, stepId: string },
-  void
->({
-  func: async ({ workflowService }, { runId, stepId }) => {
-    await workflowService!.executeWorkflowSleep(runId, stepId)
-  },
-  name: 'pikkuWorkflowStepSleeper',
-  internal: true,
-})
-
-wireQueueWorker({
-  queueName: 'pikku-workflow-step-worker',
-  func: pikkuWorkflowWorker,
-})
-
-wireQueueWorker({
-  queueName: 'pikku-workflow-orchestrator',
-  func: pikkuWorkflowOrchestrator,
-})
-`
-}

package/src/middleware/log-command-info-and-time.ts

@@ -1,35 +0,0 @@
-import type { Services } from '../../types/application-types.js'
-import type { PikkuWire } from '@pikku/core'
-
-// Middleware type for CLI
-type PikkuMiddleware = (
-  services: Services,
-  wire: PikkuWire,
-  next: () => Promise<void>
-) => Promise<void>
-
-export interface LogCommandInfoOptions {
-  commandStart: string
-  commandEnd: string
-}
-
-/**
- * Middleware to log command execution timing and status
- * Uses debug level so it only shows with --verbose flag
- */
-export const logCommandInfoAndTime = ({
-  commandStart,
-  commandEnd,
-}: LogCommandInfoOptions): PikkuMiddleware => {
-  return async ({ logger }, _wire, next) => {
-    const start = Date.now()
-    logger.debug(`• ${commandStart}...`)
-
-    await next()
-
-    logger.debug({
-      type: 'success',
-      message: `✓ ${commandEnd} in ${Date.now() - start}ms.`,
-    })
-  }
-}

package/src/services/cli-logger-forwarder.service.ts

@@ -1,99 +0,0 @@
-import { Logger, LogLevel } from '@pikku/core'
-import { PikkuChannel } from '@pikku/core/channel'
-import { ErrorCode } from '@pikku/inspector'
-
-/**
- * Log message structure sent through the channel
- */
-export interface ForwardedLogMessage {
-  message: string
-  level: 'trace' | 'debug' | 'info' | 'warn' | 'error'
-  type?: string
-}
-
-/**
- * A logger implementation that forwards log messages to a CLI channel
- * instead of logging to console directly.
- */
-export class CLILoggerForwarder implements Logger {
-  private level: LogLevel = LogLevel.info
-  private silent: boolean = false
-
-  constructor(
-    private logger: Logger,
-    private channel: PikkuChannel<unknown, any>
-  ) {}
-
-  setLevel(level: LogLevel): void {
-    this.level = level
-  }
-
-  setSilent(silent: boolean): void {
-    this.silent = silent
-  }
-
-  isSilent(): boolean {
-    return this.silent
-  }
-
-  private log(
-    level: ForwardedLogMessage['level'],
-    logLevel: LogLevel,
-    messageOrObj: string | Record<string, any> | Error,
-    type?: string
-  ) {
-    if (this.level > logLevel || this.silent) return
-
-    let message: string
-
-    if (messageOrObj instanceof Error) {
-      this.logger.error(messageOrObj.toString())
-      message = messageOrObj.message
-    } else if (typeof messageOrObj === 'object') {
-      if (
-        'message' in messageOrObj &&
-        typeof messageOrObj.message === 'string'
-      ) {
-        message = messageOrObj.message
-        type = type || (messageOrObj.type as string)
-      } else {
-        message = JSON.stringify(messageOrObj)
-      }
-    } else {
-      message = messageOrObj
-    }
-
-    this.channel.send({ message, level, type })
-  }
-
-  info(messageOrObj: string | Record<string, any>, ..._meta: any[]) {
-    this.log('info', LogLevel.info, messageOrObj)
-  }
-
-  error(messageOrObj: string | Record<string, any> | Error, ..._meta: any[]) {
-    this.log('error', LogLevel.error, messageOrObj)
-  }
-
-  warn(messageOrObj: string | Record<string, any>, ..._meta: any[]) {
-    this.log('warn', LogLevel.warn, messageOrObj)
-  }
-
-  debug(message: string, ..._meta: any[]) {
-    this.log('debug', LogLevel.debug, message)
-  }
-
-  trace(message: string, ..._meta: any[]) {
-    this.log('trace', LogLevel.trace, message)
-  }
-
-  critical(code: ErrorCode, message: string) {
-    const url = `https://pikku.dev/docs/pikku-cli/errors/${code.toLowerCase()}`
-    const formattedMessage = `[${code}] ${message}\n  → ${url}`
-    this.error(formattedMessage)
-  }
-
-  hasCriticalErrors(): boolean {
-    // The underlying logger (CLILogger) tracks critical errors
-    return (this.logger as any).hasCriticalErrors?.() ?? false
-  }
-}

package/src/services/cli-logger.service.ts

@@ -1,108 +0,0 @@
-import chalk from 'chalk'
-import { Logger, LogLevel } from '@pikku/core'
-import { ErrorCode } from '@pikku/inspector'
-
-const logo = `
- ______ _ _     _
-(_____ (_) |   | |
- _____) )| |  _| |  _ _   _
-|  ____/ | |_/ ) |_/ ) | | |
-| |    | |  _ (|  _ (|  _ (| |_| |
-|_|    |_|_| _)_| _)____/
-`
-
-const BASE_ERROR_URL = 'https://pikku.dev/docs/pikku-cli/errors'
-
-export class CLILogger implements Logger {
-  private silent: boolean
-  private level: LogLevel = LogLevel.warn // default to warn level
-  private criticalErrors: string[] = []
-
-  constructor({
-    logLogo,
-    silent = false,
-  }: {
-    logLogo: boolean
-    silent?: boolean
-  }) {
-    this.silent = silent
-    if (logLogo && !silent) {
-      this.logLogo()
-    }
-  }
-
-  setLevel(level: LogLevel): void {
-    this.level = level
-  }
-
-  setSilent(silent: boolean): void {
-    this.silent = silent
-  }
-
-  isSilent(): boolean {
-    return this.silent
-  }
-
-  info(message: string | { message: string; type?: string }) {
-    if (this.level > LogLevel.info || this.silent) return
-
-    let c = chalk.blue
-    if (typeof message === 'object') {
-      if (message.type === 'success') {
-        c = chalk.green
-      } else if (message.type === 'timing') {
-        c = chalk.gray
-      }
-    }
-    console.log(c(typeof message === 'string' ? message : message.message))
-  }
-
-  error(message: string) {
-    if (this.level > LogLevel.error) return
-    console.error(chalk.red(message))
-  }
-
-  warn(message: string) {
-    if (this.level > LogLevel.warn) return
-    console.error(chalk.yellow(message))
-  }
-
-  debug(message: string | { message: string; type?: string }) {
-    if (this.level > LogLevel.debug || this.silent) return
-
-    let c = chalk.gray
-    if (typeof message === 'object') {
-      if (message.type === 'success') {
-        c = chalk.green
-      }
-    }
-    console.log(c(typeof message === 'string' ? message : message.message))
-  }
-
-  critical(code: ErrorCode, message: string) {
-    const url = `${BASE_ERROR_URL}/${code.toLowerCase()}`
-    const formattedMessage = `[${code}] ${message}\n  → ${url}`
-    this.criticalErrors.push(formattedMessage)
-    console.error(chalk.red.bold(formattedMessage))
-  }
-
-  hasCriticalErrors(): boolean {
-    return this.criticalErrors.length > 0
-  }
-
-  logLogo() {
-    this.primary(logo)
-    // // When running from dist/, __filename is dist/src/services/cli-logger.service.js
-    // // So we need to go up 3 levels: dist/src/services -> dist/src -> dist -> package.json
-    // const packageJson = JSON.parse(
-    //   readFileSync(`${dirname(__filename)}/../../../package.json`, 'utf-8')
-    // )
-    // this.primary(`⚙️  Welcome to the Pikku CLI (v${packageJson.version})\n`)
-  }
-
-  private primary(message: string) {
-    if (!this.silent) {
-      console.log(chalk.green(message))
-    }
-  }
-}