@pikku/cli 0.9.14 → 0.9.16-next.0

package/src/functions/wirings/queue/pikku-queue.ts

@@ -0,0 +1,44 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeQueueMeta } from './serialize-queue-meta.js'
+
+export const pikkuQueue: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+    const {
+      queueWorkersWiringFile,
+      queueWorkersWiringMetaFile,
+      packageMappings,
+    } = config
+    const { queueWorkers } = visitState
+
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringMetaFile,
+      serializeQueueMeta(queueWorkers.meta)
+    )
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringFile,
+      serializeFileImports(
+        'addQueueWorkers',
+        queueWorkersWiringFile,
+        queueWorkers.files,
+        packageMappings
+      )
+    )
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding queues',
+      commandEnd: 'Found queue',
+      skipCondition: async ({ getInspectorState }) => {
+        const { queueWorkers } = await getInspectorState()
+        return queueWorkers.files.size === 0
+      },
+      skipMessage: 'none found',
+    }),
+  ],
+})

package/src/{wirings → functions/wirings}/queue/serialize-queue-map.ts

@@ -1,8 +1,8 @@
 import type { queueWorkersMeta } from '@pikku/core/queue'
-import { serializeImportMap } from '../../serialize-import-map.js'
+import { serializeImportMap } from '../../../utils/serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
-import { generateCustomTypes } from '../../utils.js'
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
 
 export const serializeQueueMap = (
   relativeToPath: string,

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

@@ -0,0 +1,31 @@
+/**
+ * Generates type definitions for queue wirings
+ */
+export const serializeQueueTypes = (functionTypesImportPath: string) => {
+  return `/**
+ * This file was generated by the @pikku/cli
+ * Queue-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreQueueWorker, wireQueueWorker as wireQueueWorkerCore } from '@pikku/core/queue'
+import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
+
+/**
+ * Type definition for queue workers that process background jobs.
+ *
+ * @template In - Input type for the queue job
+ * @template Out - Output type for the queue job
+ */
+type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out>>
+
+/**
+ * Registers a queue worker with the Pikku framework.
+ * Workers process background jobs from queues.
+ *
+ * @param queueWorker - Queue worker definition with job handler
+ */
+export const wireQueueWorker = (queueWorker: QueueWiring<any, any>) => {
+  wireQueueWorkerCore(queueWorker as any) // TODO
+}
+`
+}

package/src/functions/wirings/rpc/pikku-command-rpc-client.ts

@@ -0,0 +1,32 @@
+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 { serializeRPCWrapper } from './serialize-rpc-wrapper.js'
+
+export const pikkuRPCClient: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const { rpcWiringsFile, rpcMapDeclarationFile, packageMappings } = config
+
+    if (!rpcWiringsFile) {
+      return
+      // TODO:  throw new Error("rpcWiringsFile isn't set in the pikku config")
+    }
+
+    const rpcMapDeclarationPath = getFileImportRelativePath(
+      rpcWiringsFile,
+      rpcMapDeclarationFile,
+      packageMappings
+    )
+    const content = [serializeRPCWrapper(rpcMapDeclarationPath)]
+    await writeFileInDir(logger, rpcWiringsFile, content.join('\n'))
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating RPC wrappers',
+      commandEnd: 'Generated RPC wrappers',
+      skipCondition: ({ config }) => config.rpcWiringsFile === undefined,
+      skipMessage: "rpcWiringsFile isn't set in the pikku config",
+    }),
+  ],
+})

package/src/functions/wirings/rpc/pikku-command-rpc-map.ts

@@ -0,0 +1,52 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js'
+
+export const pikkuRPCInternalMap: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { functions, rpc } = await getInspectorState()
+    const { rpcInternalMapDeclarationFile, packageMappings } = config
+
+    const content = serializeTypedRPCMap(
+      rpcInternalMapDeclarationFile,
+      packageMappings,
+      functions.typesMap,
+      functions.meta,
+      rpc.internalMeta
+    )
+    await writeFileInDir(logger, rpcInternalMapDeclarationFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating RPC internal map',
+      commandEnd: 'Created RPC internal map',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})
+
+export const pikkuRPCExposedMap: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { functions, rpc } = await getInspectorState()
+    const { rpcMapDeclarationFile, packageMappings } = config
+
+    const content = serializeTypedRPCMap(
+      rpcMapDeclarationFile,
+      packageMappings,
+      functions.typesMap,
+      functions.meta,
+      rpc.exposedMeta
+    )
+    await writeFileInDir(logger, rpcMapDeclarationFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating RPC external map',
+      commandEnd: 'Created RPC external map',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

package/src/functions/wirings/rpc/pikku-command-rpc.ts

@@ -0,0 +1,28 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+
+export const pikkuRPC: any = pikkuSessionlessFunc<void, boolean>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { rpc } = await getInspectorState()
+    const { rpcInternalWiringMetaFile } = config
+
+    if (rpc.internalFiles.size > 0) {
+      await writeFileInDir(
+        logger,
+        rpcInternalWiringMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`
+      )
+      return true
+    }
+    return false
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding RPCs tasks',
+      commandEnd: 'Found RPCs',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

package/src/{wirings → functions/wirings}/rpc/serialize-typed-rpc-map.ts

@@ -1,7 +1,7 @@
-import { serializeImportMap } from '../../serialize-import-map.js'
+import { serializeImportMap } from '../../../utils/serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
-import { generateCustomTypes } from '../../utils.js'
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
 
 export const serializeTypedRPCMap = (
   relativeToPath: string,

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

@@ -0,0 +1,27 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeSchedulerTypes } from './serialize-scheduler-types.js'
+
+export const pikkuSchedulerTypes: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const { schedulersTypesFile, functionTypesFile, packageMappings } = config
+
+    const functionTypesImportPath = getFileImportRelativePath(
+      schedulersTypesFile,
+      functionTypesFile,
+      packageMappings
+    )
+    const content = serializeSchedulerTypes(functionTypesImportPath)
+    await writeFileInDir(logger, schedulersTypesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating cheduler types',
+      commandEnd: 'Created scheduler types',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

package/src/functions/wirings/scheduler/pikku-command-scheduler.ts

@@ -0,0 +1,46 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeSchedulerMeta } from './serialize-scheduler-meta.js'
+
+export const pikkuScheduler: any = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+    const { schedulersWiringFile, schedulersWiringMetaFile, packageMappings } =
+      config
+    const { scheduledTasks } = visitState
+
+    await writeFileInDir(
+      logger,
+      schedulersWiringMetaFile,
+      serializeSchedulerMeta(scheduledTasks.meta)
+    )
+    await writeFileInDir(
+      logger,
+      schedulersWiringFile,
+      serializeFileImports(
+        'addScheduledTasks',
+        schedulersWiringFile,
+        scheduledTasks.files,
+        packageMappings
+      )
+    )
+
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding Scheduled tasks',
+      commandEnd: 'Found Scheduled tasks',
+      skipCondition: async ({ getInspectorState }) => {
+        const visitState = await getInspectorState()
+        return visitState.scheduledTasks.files.size === 0
+      },
+      skipMessage: 'none found',
+    }),
+  ],
+})

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

@@ -0,0 +1,29 @@
+/**
+ * Generates type definitions for scheduler wirings
+ */
+export const serializeSchedulerTypes = (functionTypesImportPath: string) => {
+  return `/**
+ * This file was generated by the @pikku/cli
+ * Scheduler-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreScheduledTask, wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler'
+import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
+
+/**
+ * Type definition for scheduled tasks that run at specified intervals.
+ * These are sessionless functions that execute based on cron expressions.
+ */
+type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void>, PikkuMiddleware>
+
+/**
+ * Registers a scheduled task with the Pikku framework.
+ * Tasks run based on cron expressions and are sessionless.
+ *
+ * @param task - Scheduled task definition with cron expression and handler
+ */
+export const wireScheduler = (task: SchedulerWiring) => {
+  wireSchedulerCore(task as any) // TODO
+}
+`
+}

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

@@ -0,0 +1,61 @@
+import type {
+  SingletonServices,
+  Services,
+} from '../../types/application-types.js'
+import type { PikkuInteraction } from '@pikku/core'
+
+// Middleware type for CLI
+type PikkuMiddleware = (
+  services: Services,
+  interaction: PikkuInteraction,
+  next: () => Promise<void>
+) => Promise<void>
+
+export interface LogCommandInfoOptions {
+  commandStart: string
+  commandEnd: string
+  skipCondition?:
+    | boolean
+    | ((services: SingletonServices) => boolean | Promise<boolean>)
+  skipMessage?: string
+}
+
+/**
+ * Middleware to log command execution timing and status
+ * Replaces the logCommandInfoAndTime wrapper function
+ *
+ * The skipCondition can be:
+ * - A boolean valuewe
+ * - A function that receives services and returns a boolean (can access getInspectorState)
+ */
+export const logCommandInfoAndTime = ({
+  commandStart,
+  commandEnd,
+  skipCondition = false,
+  skipMessage = 'none found',
+}: LogCommandInfoOptions): PikkuMiddleware => {
+  return async ({ logger, ...services }, _interaction, next) => {
+    // Evaluate skip condition (can be boolean or function)
+    const shouldSkip =
+      typeof skipCondition === 'function'
+        ? await skipCondition({ logger, ...services } as any)
+        : skipCondition
+
+    if (shouldSkip === true) {
+      logger.info(
+        `• Skipping ${commandStart.charAt(0).toLocaleLowerCase()}${commandStart.slice(1)} since ${skipMessage}.`
+      )
+      return
+    }
+
+    // Log start
+    const start = Date.now()
+    logger.info(`• ${commandStart}...`)
+
+    // Execute the function
+    await next()
+
+    // Log completion
+    logger.info(`✓ ${commandEnd} in ${Date.now() - start}ms.`)
+  }
+}

package/src/serialize-pikku-types.ts

@@ -163,7 +163,7 @@ type SchedulerWiring = CoreScheduledTask<PikkuFunctionSessionless<void, void>, P
  * @template In - Input type for the queue job
  * @template Out - Output type for the queue job
  */
-type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionSessionless<In, Out>>
+type QueueWiring<In, Out> = CoreQueueWorker<any>
 
 /**
  * Type definition for MCP resources that provide data to AI models.
@@ -449,7 +449,7 @@ export { addPermission }
 export const wireHTTP = <In, Out, Route extends string>(
   httpWiring: HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>
 ) => {
-  wireHTTPCore(httpWiring)
+  wireHTTPCore(httpWiring as any) // TODO
 }
 
 /**

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

@@ -0,0 +1,77 @@
+import { Logger, LogLevel, PikkuChannel } from '@pikku/core'
+
+/**
+ * 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
+
+  constructor(
+    private logger: Logger,
+    private channel: PikkuChannel<unknown, ForwardedLogMessage>
+  ) {}
+
+  setLevel(level: LogLevel): void {
+    this.level = level
+  }
+
+  private log(
+    level: ForwardedLogMessage['level'],
+    logLevel: LogLevel,
+    messageOrObj: string | Record<string, any> | Error,
+    type?: string
+  ) {
+    if (this.level > logLevel) return
+
+    let message: string
+
+    if (messageOrObj instanceof Error) {
+      this.logger.error(messageOrObj)
+      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)
+  }
+}

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

@@ -0,0 +1,78 @@
+import chalk from 'chalk'
+import { Logger, LogLevel } from '@pikku/core'
+
+const logo = `
+ ______ _ _     _
+(_____ (_) |   | |
+ _____) )| |  _| |  _ _   _
+|  ____/ | |_/ ) |_/ ) | | |
+| |    | |  _ (|  _ (|  _ (| |_| |
+|_|    |_|_| _)_| _)____/
+`
+
+export class CLILogger implements Logger {
+  private silent: boolean
+  private level: LogLevel = LogLevel.info
+
+  constructor({
+    logLogo,
+    silent = false,
+  }: {
+    logLogo: boolean
+    silent?: boolean
+  }) {
+    this.silent = silent
+    if (logLogo && !silent) {
+      this.logPikkuLogo()
+    }
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level
+  }
+
+  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) {
+    if (this.level > LogLevel.debug || this.silent) return
+    console.log(chalk.gray(message))
+  }
+
+  private logPikkuLogo() {
+    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))
+    }
+  }
+}

package/src/services.ts

@@ -0,0 +1,111 @@
+import type {
+  Config,
+  Services,
+  SingletonServices,
+  UserSession,
+} from '../types/application-types.js'
+import {
+  CreateConfig,
+  CreateSessionServices,
+  CreateSingletonServices,
+  pikkuCLIRender,
+} from '@pikku/core'
+import { LocalVariablesService } from '@pikku/core/services'
+import { CLILogger } from './services/cli-logger.service.js'
+import { getPikkuCLIConfig } from './utils/pikku-cli-config.js'
+import { inspect, InspectorState } from '@pikku/inspector'
+import { glob } from 'tinyglobby'
+import path from 'path'
+import { PikkuCLIConfig } from '../types/config.js'
+import {
+  CLILoggerForwarder,
+  ForwardedLogMessage,
+} from './services/cli-logger-forwarder.service.js'
+
+const logger = new CLILogger({ logLogo: true, silent: false })
+
+/**
+ * Default CLI renderer that logs output using the logger
+ */
+export const defaultCLIRenderer = pikkuCLIRender<
+  ForwardedLogMessage,
+  SingletonServices
+>((_services, data) => {
+  if (data) {
+    logger[data.level]({ message: data.message, type: data.type })
+  }
+})
+
+export const createConfig: CreateConfig<Config, [PikkuCLIConfig]> = async (
+  _variablesService,
+  data
+) => {
+  const cliConfig = await getPikkuCLIConfig(
+    logger,
+    data.configFile,
+    [],
+    data,
+    true
+  )
+  return {
+    ...cliConfig,
+    ...data,
+  }
+}
+
+/**
+ * Singleton services factory for the Pikku CLI
+ * This function creates the singleton services used by the CLI and is created once on start.
+ */
+export const createSingletonServices: CreateSingletonServices<
+  Config,
+  SingletonServices
+> = async (config) => {
+  const { rootDir, srcDirectories, filters } = config
+  const variables = new LocalVariablesService()
+
+  let inspectorState: InspectorState | undefined = undefined
+  const getInspectorState = async (refresh: boolean = false) => {
+    if (refresh || !inspectorState) {
+      const wiringFiles = (
+        await Promise.all(
+          srcDirectories.map((dir) =>
+            glob(`${path.join(rootDir, dir)}/**/*.ts`)
+          )
+        )
+      ).flat()
+      inspectorState = await inspect(logger, wiringFiles, {
+        filters,
+        types: {
+          configFileType: config.configFile,
+          userSessionType: config.tags?.[0], // TODO: Properly handle type selection
+          singletonServicesFactoryType: undefined,
+          sessionServicesFactoryType: undefined,
+        },
+      })
+      return inspectorState
+    }
+    return inspectorState!
+  }
+
+  return {
+    config,
+    logger,
+    variables,
+    getInspectorState,
+  }
+}
+
+export const createSessionServices: CreateSessionServices<
+  SingletonServices,
+  Services,
+  UserSession
+> = async ({ logger }, { cli, channel }) => {
+  const vChannel = cli ? cli.channel : channel
+  if (!vChannel) {
+    throw new Error('No channel provided for CLI services')
+  }
+  return {
+    logger: new CLILoggerForwarder(logger, vChannel),
+  }
+}