@pikku/cli 0.10.0 → 0.10.2

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

@@ -5,6 +5,8 @@ import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 
 export const serializeServicesMap = (
+  allSingletonServices: string[],
+  allSessionServices: string[],
   requiredServices: Set<string>,
   forceRequiredServices: string[] = [],
   servicesImport: string,
@@ -18,8 +20,18 @@ export const serializeServicesMap = (
   // - Session factories
   const usedServices = new Set(requiredServices)
 
-  // Internal services that are created internally and not via the create service script
-  const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession'])
+  // Internal services that are created internally by the framework (PikkuInteraction)
+  // These should not appear in the services maps
+  const internalServices = new Set([
+    'rpc',
+    'mcp',
+    'channel',
+    'userSession',
+    'cli',
+    'http',
+    'queue',
+    'scheduledTask',
+  ])
 
   // Add force-required services that might not be detected from function inspection
   forceRequiredServices.forEach((service) => {
@@ -28,44 +40,59 @@ export const serializeServicesMap = (
     }
   })
 
-  // Create a map of services with true for all needed services
-  const servicesMap = Object.fromEntries(
-    Array.from(usedServices)
-      .sort()
-      .map((service) => [service, true])
-  )
-
-  // Generate the TypeScript code
-  const serviceKeys = Object.keys(servicesMap).sort()
-
   // Services that are always required internally by the framework
   const defaultServices = ['config', 'logger', 'variables', 'schema']
+  defaultServices.forEach((service) => usedServices.add(service))
 
-  // Combine default services with detected services
-  const allRequiredServices = [
-    ...new Set([...defaultServices, ...serviceKeys]),
-  ].sort()
+  // Create singleton services map: all singleton services with true/false based on usage
+  const singletonServicesMap: Record<string, boolean> = {}
+  allSingletonServices.forEach((service) => {
+    singletonServicesMap[service] = usedServices.has(service)
+  })
+
+  // Create session services map: all session services with true/false based on usage
+  // Exclude internal framework services (PikkuInteraction)
+  const sessionServicesMap: Record<string, boolean> = {}
+  allSessionServices.forEach((service) => {
+    if (!internalServices.has(service)) {
+      sessionServicesMap[service] = usedServices.has(service)
+    }
+  })
 
-  // For RequiredSingletonServices, we need to pick from the actual SingletonServices interface
-  // This will be resolved at compile time based on what's actually in the SingletonServices interface
-  // We don't need to hardcode which services are singletons beyond the core framework ones
+  // Get all required service names (those marked as true)
+  const requiredSingletonServiceNames = Object.keys(singletonServicesMap)
+    .filter((key) => singletonServicesMap[key])
+    .sort()
+  const requiredSessionServiceNames = Object.keys(sessionServicesMap)
+    .filter((key) => sessionServicesMap[key])
+    .sort()
 
   const code = [
     servicesImport,
     sessionServicesImport,
-    "import type { PikkuInteraction } from '@pikku/core'",
     '',
-    'export const singletonServices = {',
-    ...Object.keys(servicesMap).map((service) => `    '${service}': true,`),
+    '// Singleton services map: true if required, false if available but unused',
+    'export const requiredSingletonServices = {',
+    ...Object.keys(singletonServicesMap)
+      .sort()
+      .map((service) => `  '${service}': ${singletonServicesMap[service]},`),
+    '} as const',
+    '',
+    '// Session services map: true if required, false if available but unused',
+    'export const requiredSessionServices = {',
+    ...Object.keys(sessionServicesMap)
+      .sort()
+      .map((service) => `  '${service}': ${sessionServicesMap[service]},`),
     '} as const',
     '',
-    '// Singleton services (created once at startup)',
-    '// Only includes services that are both required and available in SingletonServices',
-    `export type RequiredSingletonServices = Pick<SingletonServices, Extract<keyof SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>> & Partial<Omit<SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>>`,
+    '// Type exports',
+    requiredSingletonServiceNames.length > 0
+      ? `export type RequiredSingletonServices = Pick<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+      : 'export type RequiredSingletonServices = Partial<SingletonServices>',
     '',
-    '// Session services (created per request, can access singleton services)',
-    '// Omits singleton services and PikkuInteraction (mcp, rpc, http, channel)',
-    `export type RequiredSessionServices = Omit<Services, keyof SingletonServices | keyof PikkuInteraction>`,
+    requiredSessionServiceNames.length > 0
+      ? `export type RequiredSessionServices = Pick<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+      : 'export type RequiredSessionServices = Partial<Services>',
     '',
   ].join('\n')
 
@@ -95,6 +122,8 @@ export const pikkuServices: any = pikkuSessionlessFunc<void, void>({
     const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`
 
     const servicesCode = serializeServicesMap(
+      visitState.serviceAggregation.allSingletonServices,
+      visitState.serviceAggregation.allSessionServices,
       visitState.serviceAggregation.requiredServices,
       config.forceRequiredServices,
       servicesImport,

package/src/functions/wirings/functions/schemas.ts

@@ -21,7 +21,8 @@ export const pikkuSchemas: any = pikkuSessionlessFunc<
       visitState.functions.typesMap,
       visitState.functions.meta,
       visitState.http.meta,
-      config.schemasFromTypes
+      config.schemasFromTypes,
+      config.schema?.additionalProperties
     )
 
     await saveSchemas(
@@ -30,8 +31,8 @@ export const pikkuSchemas: any = pikkuSessionlessFunc<
       schemas,
       visitState.functions.typesMap,
       visitState.functions.meta,
-      config.supportsImportAttributes,
-      config.schemasFromTypes
+      config.schemasFromTypes,
+      config.schema?.supportsImportAttributes
     )
 
     return true

package/src/functions/wirings/http/pikku-command-openapi.ts

@@ -27,7 +27,8 @@ export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
       functions.typesMap,
       functions.meta,
       http.meta,
-      schemasFromTypes
+      schemasFromTypes,
+      config.schema?.additionalProperties
     )
     const openAPISpec = await generateOpenAPISpec(
       logger,

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

@@ -15,17 +15,18 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
 
     let filesGenerated = false
 
-    // Check if there are any middleware group factories
-    const hasHTTPFactories = Array.from(
-      state.http.routeMiddleware.values()
-    ).some((meta) => meta.exportName && meta.isFactory)
-    const hasTagFactories = Array.from(
-      state.middleware.tagMiddleware.values()
-    ).some((meta) => meta.exportName && meta.isFactory)
-    const hasFactories = hasHTTPFactories || hasTagFactories
+    // Check if there are any middleware groups
+    const hasHTTPGroups = state.http.routeMiddleware.size > 0
+    const hasTagGroups = state.middleware.tagMiddleware.size > 0
+
+    if (hasHTTPGroups || hasTagGroups) {
+      await writeFileInDir(
+        logger,
+        config.middlewareGroupsMetaFile,
+        serializeMiddlewareGroupsMeta(state)
+      )
 
-    // Generate middleware imports file if there are factories
-    if (hasFactories) {
+      // Always generate middleware imports file when groups exist (even if empty)
       await writeFileInDir(
         logger,
         middlewareFile,
@@ -36,19 +37,7 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
           packageMappings
         )
       )
-      filesGenerated = true
-    }
 
-    // Generate middleware groups metadata file
-    const hasHTTPGroups = state.http.routeMiddleware.size > 0
-    const hasTagGroups = state.middleware.tagMiddleware.size > 0
-
-    if (hasHTTPGroups || hasTagGroups) {
-      await writeFileInDir(
-        logger,
-        config.middlewareGroupsMetaFile,
-        serializeMiddlewareGroupsMeta(state)
-      )
       filesGenerated = true
     }
 

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

@@ -15,21 +15,24 @@ export interface LogCommandInfoOptions {
 
 /**
  * Middleware to log command execution timing and status
- * Replaces the logCommandInfoAndTime wrapper function
+ * Uses debug level so it only shows with --verbose flag
  */
 export const logCommandInfoAndTime = ({
   commandStart,
   commandEnd,
 }: LogCommandInfoOptions): PikkuMiddleware => {
   return async ({ logger }, _interaction, next) => {
-    // Log start
+    // Log start (debug level - only shows with --verbose)
     const start = Date.now()
-    logger.info(`• ${commandStart}...`)
+    logger.debug(`• ${commandStart}...`)
 
     // Execute the function
     await next()
 
-    // Log completion
-    logger.info(`✓ ${commandEnd} in ${Date.now() - start}ms.`)
+    // Log completion (debug level - only shows with --verbose)
+    logger.debug({
+      type: 'success',
+      message: `✓ ${commandEnd} in ${Date.now() - start}ms.`,
+    })
   }
 }

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

@@ -15,7 +15,7 @@ const BASE_ERROR_URL = 'https://pikku.dev/errors'
 
 export class CLILogger implements Logger {
   private silent: boolean
-  private level: LogLevel = LogLevel.info
+  private level: LogLevel = LogLevel.warn // default to warn level
   private criticalErrors: string[] = []
 
   constructor({
@@ -27,7 +27,7 @@ export class CLILogger implements Logger {
   }) {
     this.silent = silent
     if (logLogo && !silent) {
-      this.logPikkuLogo()
+      this.logLogo()
     }
   }
 
@@ -35,6 +35,14 @@ export class CLILogger implements Logger {
     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
 
@@ -59,9 +67,16 @@ export class CLILogger implements Logger {
     console.error(chalk.yellow(message))
   }
 
-  debug(message: string) {
+  debug(message: string | { message: string; type?: string }) {
     if (this.level > LogLevel.debug || this.silent) return
-    console.log(chalk.gray(message))
+
+    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) {
@@ -75,7 +90,7 @@ export class CLILogger implements Logger {
     return this.criticalErrors.length > 0
   }
 
-  private logPikkuLogo() {
+  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

package/src/services.ts

@@ -10,7 +10,7 @@ import {
   CreateSingletonServices,
 } from '@pikku/core'
 import { pikkuCLIRender } from '@pikku/core/cli'
-import { LocalVariablesService } from '@pikku/core/services'
+import { LocalVariablesService, LogLevel } from '@pikku/core/services'
 import { CLILogger } from './services/cli-logger.service.js'
 import { getPikkuCLIConfig } from './utils/pikku-cli-config.js'
 import {
@@ -20,6 +20,7 @@ import {
   serializeInspectorState,
   deserializeInspectorState,
   filterInspectorState,
+  getInitialInspectorState,
 } from '@pikku/inspector'
 import { glob } from 'tinyglobby'
 import path from 'path'
@@ -30,7 +31,9 @@ import {
 } from './services/cli-logger-forwarder.service.js'
 import { readFile, writeFile } from 'fs/promises'
 
-const logger = new CLILogger({ logLogo: true, silent: false })
+// Logger instance will be configured with log level from CLI flags in createConfig
+// Logo will be displayed conditionally in createConfig based on --silent flag
+const logger = new CLILogger({ logLogo: false, silent: false })
 
 /**
  * Parse a comma-separated string or array into an array of trimmed, non-empty strings
@@ -94,7 +97,7 @@ function parseCLIFilters(data: any): InspectorFilters {
 export const defaultCLIRenderer = pikkuCLIRender<
   ForwardedLogMessage,
   SingletonServices
->((_services, data) => {
+>(({ logger }, data) => {
   if (data) {
     logger[data.level]({ message: data.message, type: data.type })
   }
@@ -105,11 +108,9 @@ export const defaultCLIRenderer = pikkuCLIRender<
  * This renderer can be used in CLI-over-channel clients
  */
 export const clientCLIRenderer = pikkuCLIRender<ForwardedLogMessage>(
-  (_services, data) => {
+  ({ logger }, data) => {
     if (data) {
-      // Simple console output without service dependencies
-      const prefix = data.type ? `[${data.type}] ` : ''
-      console.log(`${prefix}${data.message}`)
+      logger[data.level]?.({ message: data.message, type: data.type } as any)
     }
   }
 )
@@ -118,6 +119,37 @@ export const createConfig: CreateConfig<Config, [PikkuCLIConfig]> = async (
   _variablesService,
   data
 ) => {
+  // Determine log level based on CLI flags with precedence:
+  // --silent > --loglevel > --verbose > --info > default (warn)
+  let logLevel: LogLevel = LogLevel.warn // default
+  let isSilent = false
+
+  if ((data as any).silent) {
+    logLevel = LogLevel.critical
+    isSilent = true
+  } else if ((data as any).loglevel) {
+    const levelStr = (data as any).loglevel
+    if (LogLevel[levelStr] !== undefined) {
+      logLevel = LogLevel[levelStr as keyof typeof LogLevel]
+    } else {
+      logger.warn(
+        `Invalid log level "${levelStr}". Valid levels: trace, debug, info, warn, error, critical. Using default (warn).`
+      )
+    }
+  } else if ((data as any).verbose) {
+    logLevel = LogLevel.debug
+  } else if ((data as any).info) {
+    logLevel = LogLevel.info
+  }
+
+  logger.setLevel(logLevel)
+  logger.setSilent(isSilent)
+
+  // Display logo unless in silent mode
+  if (!isSilent) {
+    logger.logLogo()
+  }
+
   const cliConfig = await getPikkuCLIConfig(logger, data.configFile, [], true)
 
   // Load inspector state from file if stateInput is provided
@@ -170,19 +202,62 @@ export const createSingletonServices: CreateSingletonServices<
     | Omit<InspectorState, 'typesLookup'>
     | undefined = preloadedInspectorState
 
-  const getInspectorState = async (refresh: boolean = false) => {
+  const getInspectorState = async (
+    refresh: boolean = false,
+    setupOnly: boolean = false,
+    bootstrapMode: boolean = false
+  ) => {
+    // In bootstrap mode, return a minimal "zero state" with core types
+    // This allows bootstrap to run immediately without inspecting the codebase
+    if (bootstrapMode) {
+      const corePackagePath = '@pikku/core'
+      const initialState = getInitialInspectorState(rootDir)
+
+      // Populate filesAndMethods with core types from @pikku/core
+      initialState.filesAndMethods = {
+        userSessionType: {
+          file: corePackagePath,
+          variable: 'CoreUserSession',
+          type: 'CoreUserSession',
+          typePath: corePackagePath,
+        },
+        sessionServicesType: {
+          file: corePackagePath,
+          variable: 'CoreServices',
+          type: 'CoreServices',
+          typePath: corePackagePath,
+        },
+        singletonServicesType: {
+          file: corePackagePath,
+          variable: 'CoreSingletonServices',
+          type: 'CoreSingletonServices',
+          typePath: corePackagePath,
+        },
+        pikkuConfigType: {
+          file: corePackagePath,
+          variable: 'CoreConfig',
+          type: 'CoreConfig',
+          typePath: corePackagePath,
+        },
+      }
+
+      return initialState
+    }
+
     // Get or refresh the unfiltered state
     if (!unfilteredState || refresh) {
       // Run inspector WITHOUT filters to get full state
       const wiringFiles = (
         await Promise.all(
           srcDirectories.map((dir) =>
-            glob(`${path.join(rootDir, dir)}/**/*.ts`)
+            glob(`${path.join(rootDir, dir)}/**/*.ts`, {
+              ignore: config.ignoreFiles || [],
+            })
           )
         )
       ).flat()
-      unfilteredState = await inspect(logger, wiringFiles, {
-        // NO filters here - inspector returns full unfiltered state
+      unfilteredState = inspect(logger, wiringFiles, {
+        setupOnly,
         types: {
           configFileType: config.configFile,
           userSessionType: config.userSessionType,

package/src/utils/check-required-types.ts

@@ -13,8 +13,23 @@ export const checkRequiredTypes = (
   errors: FilesAndMethodsErrors,
   requires: RequiredTypes = {}
 ): void => {
+  // Filter out errors that are about missing Types when we have the corresponding Factory
+  // e.g., if we have a CreateConfig factory, we don't need a CoreConfig type
+  const errorMessages = Array.from(errors.keys())
+  const hasCreateConfigFactory = errorMessages.every(
+    (msg) => !msg.includes('No CreateConfig found')
+  )
+
   // Only throw if there are errors AND we require those types
-  const hasRequiredErrors = Array.from(errors.keys()).some((message) => {
+  const hasRequiredErrors = errorMessages.some((message) => {
+    // Skip CoreConfig type errors if we have a CreateConfig factory
+    if (
+      requires.config &&
+      message.includes('No CoreConfig found') &&
+      hasCreateConfigFactory
+    ) {
+      return false
+    }
     if (requires.config && message.includes('CoreConfig')) return true
     if (requires.sessionServiceType && message.includes('CoreServices'))
       return true

package/src/utils/command-summary.ts

@@ -0,0 +1,101 @@
+import chalk from 'chalk'
+
+export interface CommandSummaryStats {
+  httpRoutes?: number
+  channels?: number
+  functions?: number
+  scheduledTasks?: number
+  queueWorkers?: number
+  mcpEndpoints?: number
+  cliCommands?: number
+  [key: string]: number | undefined
+}
+
+/**
+ * Utility class to collect and display command execution summaries
+ */
+export class CommandSummary {
+  private stats: CommandSummaryStats = {}
+  private startTime: number
+  private commandName: string
+
+  constructor(commandName: string) {
+    this.commandName = commandName
+    this.startTime = Date.now()
+  }
+
+  /**
+   * Increment a stat counter
+   */
+  increment(key: keyof CommandSummaryStats, count: number = 1): void {
+    this.stats[key] = (this.stats[key] || 0) + count
+  }
+
+  /**
+   * Set a stat value directly
+   */
+  set(key: keyof CommandSummaryStats, value: number): void {
+    this.stats[key] = value
+  }
+
+  /**
+   * Get current stats
+   */
+  getStats(): CommandSummaryStats {
+    return { ...this.stats }
+  }
+
+  /**
+   * Get elapsed time in milliseconds
+   */
+  getElapsedTime(): number {
+    return Date.now() - this.startTime
+  }
+
+  /**
+   * Format the summary for display
+   */
+  format(): string {
+    const elapsed = this.getElapsedTime()
+    const lines: string[] = []
+
+    // Header with timing
+    lines.push(
+      chalk.green(`\npikku ${this.commandName} (completed in ${elapsed}ms)`)
+    )
+
+    // Stats
+    const statLabels: Record<keyof CommandSummaryStats, string> = {
+      httpRoutes: 'HTTP routes',
+      channels: 'WebSocket channels',
+      functions: 'functions',
+      scheduledTasks: 'scheduled tasks',
+      queueWorkers: 'queue workers',
+      mcpEndpoints: 'MCP endpoints',
+      cliCommands: 'CLI commands',
+    }
+
+    for (const [key, label] of Object.entries(statLabels)) {
+      const value = this.stats[key]
+      if (value !== undefined && value > 0) {
+        lines.push(chalk.gray(`  • ${value} ${label}`))
+      }
+    }
+
+    // If no stats, show a simple completion message
+    if (Object.values(this.stats).every((v) => !v || v === 0)) {
+      return chalk.green(
+        `\npikku ${this.commandName} (completed in ${elapsed}ms)\n`
+      )
+    }
+
+    return lines.join('\n') + '\n'
+  }
+
+  /**
+   * Check if there are any stats to display
+   */
+  hasStats(): boolean {
+    return Object.values(this.stats).some((v) => v && v > 0)
+  }
+}

package/src/utils/file-writer.ts

@@ -51,7 +51,7 @@ export const writeFileInDir = async (
     await writeFile(path, content, 'utf-8')
 
     if (logWrite) {
-      logger.info({ message: `✓ File written to ${path}`, type: 'success' })
+      logger.debug({ message: `✓ File written to ${path}`, type: 'success' })
     }
   }
 }
@@ -66,7 +66,7 @@ export const removeFileInDir = async (
     await rm(path, { force: true })
 
     if (logRemove) {
-      logger.info({ message: `✓ File removed at ${path}`, type: 'success' })
+      logger.debug({ message: `✓ File removed at ${path}`, type: 'success' })
     }
   }
 }

package/src/utils/pikku-cli-config.ts

@@ -64,6 +64,21 @@ const _getPikkuCLIConfig = async (
           ...extendedConfig.packageMappings,
           ...config.packageMappings,
         },
+        ignoreFiles: config.ignoreFiles ??
+          extendedConfig.ignoreFiles ?? [
+            '**/*.gen.ts',
+            '**/*.test.ts',
+            '**/*.spec.ts',
+            '**/node_modules/**',
+            '**/.pikku/**',
+            '**/dist/**',
+          ],
+        schema: {
+          additionalProperties: false,
+          supportsImportAttributes: false,
+          ...extendedConfig.schema,
+          ...config.schema,
+        },
       }
     } else {
       result = {
@@ -73,6 +88,19 @@ const _getPikkuCLIConfig = async (
         rootDir: config.rootDir
           ? resolve(configDir, config.rootDir)
           : configDir,
+        ignoreFiles: config.ignoreFiles ?? [
+          '**/*.gen.ts',
+          '**/*.test.ts',
+          '**/*.spec.ts',
+          '**/node_modules/**',
+          '**/.pikku/**',
+          '**/dist/**',
+        ],
+        schema: {
+          additionalProperties: false,
+          supportsImportAttributes: false,
+          ...config.schema,
+        },
       }
     }
 

package/src/utils/schema-generator.ts

@@ -12,7 +12,8 @@ export async function generateSchemas(
   typesMap: TypesMap,
   functionMeta: FunctionsMeta,
   httpWiringsMeta: HTTPWiringsMeta,
-  additionalTypes?: string[]
+  additionalTypes?: string[],
+  additionalProperties: boolean = false
 ): Promise<Record<string, JSONValue>> {
   const schemasSet = new Set(typesMap.customTypes.keys())
   for (const { inputs, outputs } of Object.values(functionMeta)) {
@@ -56,7 +57,7 @@ export async function generateSchemas(
     sortProps: true,
     strictTuples: false,
     encodeRefs: false,
-    additionalProperties: false,
+    additionalProperties,
   })
   const schemas: Record<string, JSONValue> = {}
 
@@ -86,8 +87,8 @@ export async function saveSchemas(
   schemas: Record<string, JSONValue>,
   typesMap: TypesMap,
   functionsMeta: FunctionsMeta,
-  supportsImportAttributes: boolean,
-  additionalTypes?: string[]
+  additionalTypes?: string[],
+  supportsImportAttributes: boolean = false
 ) {
   await writeFileInDir(
     logger,