@pikku/cli 0.7.6 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @pikku/cli
 
+## 0.8.0
+
+### Major Features
+
+- **Model Context Protocol (MCP) Support**: Complete MCP implementation with automatic generation of MCP JSON specifications, resources, tools, and prompts
+- **Queue System**: Added queue support
+- **RPC (Remote Procedure Calls)**: Added typed RPC call generation with local and remote procedure support
+- **Multiple Bootstrap Files**: Added support for generating different transport-specific bootstrap files
+- **Service Destructuring Analysis**: Added service destructuring analysis for better code generation
+- **Bootstrap Files**: Added support for generating transport-specific bootstrap files
+- **Service Destructuring**: Added service destructuring analysis for better code organization
+- **Error Handling**: Improved error handling for complex type generation
+- **Performance**: Optimized code generation for large projects with multiple event types
+
+## 0.7.7
+
+### Patch Changes
+
+- a5e3903: fix: PikkuFetch import fix
+
 ## 0.7.6
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -1,32 +1,40 @@
 import { Command } from 'commander'
 import {
+  CLILogger,
   getFileImportRelativePath,
-  logInfo,
-  logPikkuLogo,
   PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils/utils.js'
+} from '../src/utils.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuHTTP } from './pikku-http-routes.js'
-import { pikkuFunctionTypes } from './pikku-function-types.js'
-import { pikkuHTTPMap } from './pikku-http-map.js'
+import { pikkuHTTP } from '../src/events/http/pikku-command-http-routes.js'
+import { pikkuFunctionTypes } from '../src/events/functions/pikku-command-function-types.js'
+import { pikkuHTTPMap } from '../src/events/http/pikku-command-http-map.js'
 import { existsSync } from 'fs'
-import { pikkuFetch } from './pikku-fetch.js'
-import { pikkuChannelsMap } from './pikku-channels-map.js'
-import { pikkuChannels } from './pikku-channels.js'
-import { pikkuNext } from './pikku-nextjs.js'
-import { pikkuOpenAPI } from './pikku-openapi.js'
-import { pikkuScheduler } from './pikku-scheduler.js'
-import { pikkuSchemas } from './pikku-schemas.js'
-import { pikkuWebSocket } from './pikku-websocket.js'
+import { pikkuChannelsMap } from '../src/events/channels/pikku-command-channels-map.js'
+import { pikkuChannels } from '../src/events/channels/pikku-command-channels.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 import chokidar from 'chokidar'
-import { pikkuFunctions } from './pikku-functions.js'
-import { pikkuRPC } from './pikku-rpc.js'
-import { pikkuRPCMap } from './pikku-rpc-map.js'
+import { pikkuFunctions } from '../src/events/functions/pikku-command-functions.js'
+import { pikkuRPC } from '../src/events/rpc/pikku-command-rpc.js'
+import { pikkuRPCMap } from '../src/events/rpc/pikku-command-rpc-map.js'
 import { PikkuEventTypes } from '@pikku/core'
+import { pikkuQueue } from '../src/events/queue/pikku-command-queue.js'
+import { pikkuQueueMap } from '../src/events/queue/pikku-command-queue-map.js'
+import { pikkuFetch } from '../src/events/fetch/index.js'
+import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js'
+import { pikkuNext } from '../src/events/http/pikku-command-nextjs.js'
+import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js'
+import { pikkuMCP } from '../src/events/mcp/pikku-command-mcp.js'
+import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js'
+import { pikkuScheduler } from '../src/events/scheduler/pikku-command-scheduler.js'
+import { pikkuSchemas } from '../src/schemas.js'
+import { pikkuMCPJSON } from '../src/events/mcp/pikku-command-mcp-json.js'
 
-const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
+const runAll = async (
+  logger: CLILogger,
+  cliConfig: PikkuCLIConfig,
+  options: PikkuCLIOptions
+) => {
   const boostrapImports: Partial<
     Record<PikkuEventTypes, { meta: string[]; events: string[] }>
   > & { all: { meta: string[]; events: string[] } } = {
@@ -38,11 +46,10 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
     type: 'meta' | 'events' | 'other',
     addTo?: PikkuEventTypes[]
   ) => {
-    const statement = `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`
     if (type === 'meta') {
-      boostrapImports.all.meta.push(statement)
+      boostrapImports.all.meta.push(from)
     } else {
-      boostrapImports.all.events.push(statement)
+      boostrapImports.all.events.push(from)
     }
 
     for (const transport of Object.keys(PikkuEventTypes)) {
@@ -52,9 +59,9 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
           events: [],
         }
         if (type === 'meta') {
-          boostrapImports[transport].meta.push(statement)
+          boostrapImports[transport].meta.push(from)
         } else {
-          boostrapImports[transport].events.push(statement)
+          boostrapImports[transport].events.push(from)
         }
       }
     }
@@ -62,6 +69,7 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
 
   let typesDeclarationFileExists = true
   let visitState = await inspectorGlob(
+    logger,
     cliConfig.rootDir,
     cliConfig.srcDirectories,
     cliConfig.filters
@@ -70,80 +78,111 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
   if (!existsSync(cliConfig.typesDeclarationFile)) {
     typesDeclarationFileExists = false
   }
-  await pikkuFunctionTypes(cliConfig, options, visitState)
+  await pikkuFunctionTypes(logger, cliConfig, visitState, options)
 
   // This is needed since the addHTTPRoute function will add the routes to the visitState
   if (!typesDeclarationFileExists) {
-    logInfo(`• Type file first created, inspecting again...\x1b[0m`)
+    logger.info(`• Type file first created, inspecting again...\x1b[0m`)
     visitState = await inspectorGlob(
+      logger,
       cliConfig.rootDir,
       cliConfig.srcDirectories,
       cliConfig.filters
     )
   }
 
-  const functions = pikkuFunctions(cliConfig, visitState)
+  const functions = pikkuFunctions(logger, cliConfig, visitState)
   if (!functions) {
-    logInfo(`• No functions found, skipping remaining steps...\x1b[0m`)
+    logger.info(`• No functions found, skipping remaining steps...\x1b[0m`)
     process.exit(1)
   }
   addImport(cliConfig.functionsMetaFile, 'meta')
   addImport(cliConfig.functionsFile, 'events')
 
-  await pikkuRPC(cliConfig, visitState)
-  await pikkuRPCMap(cliConfig, visitState)
+  await pikkuRPC(logger, cliConfig, visitState)
+  await pikkuRPCMap(logger, cliConfig, visitState)
   addImport(cliConfig.rpcMetaFile, 'meta', [PikkuEventTypes.rpc])
 
-  const schemas = await pikkuSchemas(cliConfig, visitState)
+  const schemas = await pikkuSchemas(logger, cliConfig, visitState)
   if (schemas) {
     addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other')
   }
 
-  const http = await pikkuHTTP(cliConfig, visitState)
+  const http = await pikkuHTTP(logger, cliConfig, visitState)
   if (http) {
-    await pikkuHTTPMap(cliConfig, visitState)
-    await pikkuFetch(cliConfig)
+    await pikkuHTTPMap(logger, cliConfig, visitState)
+    await pikkuFetch(logger, cliConfig)
     addImport(cliConfig.httpRoutesMetaFile, 'meta', [PikkuEventTypes.http])
     addImport(cliConfig.httpRoutesFile, 'events', [PikkuEventTypes.http])
   }
 
-  const scheduled = await pikkuScheduler(cliConfig, visitState)
+  const scheduled = await pikkuScheduler(logger, cliConfig, visitState)
   if (scheduled) {
     addImport(cliConfig.schedulersMetaFile, 'meta', [PikkuEventTypes.scheduled])
     addImport(cliConfig.schedulersFile, 'events', [PikkuEventTypes.scheduled])
   }
 
-  const channels = await pikkuChannels(cliConfig, visitState)
+  const queues = await pikkuQueue(logger, cliConfig, visitState)
+  if (queues) {
+    await pikkuQueueMap(logger, cliConfig, visitState)
+    await pikkuQueueService(logger, cliConfig)
+    addImport(cliConfig.queueWorkersMetaFile, 'meta', [PikkuEventTypes.queue])
+    addImport(cliConfig.queueWorkersFile, 'events', [PikkuEventTypes.queue])
+  }
+
+  const channels = await pikkuChannels(logger, cliConfig, visitState)
   if (channels) {
-    await pikkuChannelsMap(cliConfig, visitState)
-    await pikkuWebSocket(cliConfig)
+    await pikkuChannelsMap(logger, cliConfig, visitState)
+    await pikkuWebSocketTyped(logger, cliConfig)
     addImport(cliConfig.channelsMetaFile, 'meta', [PikkuEventTypes.channel])
     addImport(cliConfig.channelsFile, 'events', [PikkuEventTypes.channel])
   }
 
+  const mcp = await pikkuMCP(logger, cliConfig, visitState)
+  if (mcp) {
+    await pikkuMCPJSON(logger, cliConfig, visitState)
+    addImport(cliConfig.mcpEndpointsMetaFile, 'meta', [PikkuEventTypes.mcp])
+    addImport(cliConfig.mcpEndpointsFile, 'events', [PikkuEventTypes.mcp])
+  }
+
   if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
-    await pikkuNext(cliConfig, visitState, options)
+    await pikkuNext(logger, cliConfig, visitState, options)
   }
 
   if (cliConfig.openAPI) {
-    logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`)
+    logger.info(
+      `• OpenAPI requires a reinspection to pickup new generated types..`
+    )
     visitState = await inspectorGlob(
+      logger,
       cliConfig.rootDir,
       cliConfig.srcDirectories,
       cliConfig.filters
     )
-    await pikkuOpenAPI(cliConfig, visitState)
+    await pikkuOpenAPI(logger, cliConfig, visitState)
   }
 
   for (const [type, { meta, events }] of Object.entries(boostrapImports)) {
+    const bootstrapFile =
+      type === 'all' ? cliConfig.bootstrapFile : cliConfig.bootstrapFiles[type]
     await writeFileInDir(
-      type === 'all' ? cliConfig.bootstrapFile : cliConfig.bootstrapFiles[type],
-      [...meta, ...events].join('\n')
+      logger,
+      bootstrapFile,
+      [...meta, ...events]
+        .map(
+          (to) =>
+            `import '${getFileImportRelativePath(bootstrapFile, to, cliConfig.packageMappings)}'`
+        )
+        .join('\n')
     )
   }
 }
 
-const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
+const watch = (
+  logger: CLILogger,
+  cliConfig: PikkuCLIConfig,
+  options: PikkuCLIOptions
+) => {
   const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
     ignoreInitial: true,
     ignored: /.*\.gen\.tsx?/,
@@ -154,7 +193,7 @@ const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
   const generatorWatcher = () => {
     watcher.close()
 
-    logInfo(
+    logger.info(
       `• Watching directories: \n  - ${cliConfig.srcDirectories.join('\n  - ')}`
     )
     watcher = chokidar.watch(cliConfig.srcDirectories, {
@@ -165,7 +204,7 @@ const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
     watcher.on('ready', async () => {
       const handle = async () => {
         try {
-          await runAll(cliConfig, options)
+          await runAll(logger, cliConfig, options)
         } catch (err) {
           console.error(err)
           console.info()
@@ -194,7 +233,7 @@ const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
 }
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
 
   const cliConfig = await getPikkuCLIConfig(
     options.config,
@@ -204,9 +243,9 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   )
 
   if (options.watch) {
-    watch(cliConfig, options)
+    watch(logger, cliConfig, options)
   } else {
-    await runAll(cliConfig, options)
+    await runAll(logger, cliConfig, options)
   }
 }
 

package/bin/pikku-fetch.ts

@@ -1,49 +1,17 @@
 import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { serializeFetchWrapper } from '../src/serialize-fetch-wrapper.js'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-
-export const pikkuFetch = async ({
-  fetchFile,
-  httpRoutesMapDeclarationFile,
-  packageMappings,
-}: PikkuCLIConfig) => {
-  await logCommandInfoAndTime(
-    'Generating fetch wrapper',
-    'Generated fetch wrapper',
-    [fetchFile === undefined, "fetchFile isn't set in the pikku config"],
-    async () => {
-      if (!fetchFile) {
-        throw new Error("fetchFile is isn't set in the pikku config")
-      }
-
-      const routesMapDeclarationPath = getFileImportRelativePath(
-        fetchFile,
-        httpRoutesMapDeclarationFile,
-        packageMappings
-      )
-
-      const content = [serializeFetchWrapper(routesMapDeclarationPath)]
-      await writeFileInDir(fetchFile, content.join('\n'))
-    }
-  )
-}
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { pikkuFetch } from '../src/events/fetch/index.js'
+import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
     options.tags,
     true
   )
-  await pikkuFetch(cliConfig)
+  await pikkuFetch(logger, cliConfig)
 }
 
 export const fetch = (program: Command): void => {

package/bin/pikku-nextjs.ts

@@ -1,118 +1,12 @@
 import { Command } from 'commander'
-import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/serialize-nextjs-backend-wrapper.js'
-import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/serialize-nextjs-http-wrapper.js'
-import {
-  getFileImportRelativePath,
-  getPikkuFilesAndMethods,
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
+import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuNext = async (
-  {
-    nextBackendFile,
-    nextHTTPFile,
-    httpRoutesMapDeclarationFile,
-    packageMappings,
-    fetchFile,
-    bootstrapFiles,
-  }: PikkuCLIConfig,
-  visitState: InspectorState,
-  options: PikkuCLIOptions
-) => {
-  return await logCommandInfoAndTime(
-    'Generating nextjs wrapper',
-    'Generated nextjs wrapper',
-    [
-      nextBackendFile === undefined && nextHTTPFile === undefined,
-      'nextjs outfile is not defined',
-    ],
-    async () => {
-      if (!nextBackendFile && !nextHTTPFile) {
-        throw new Error(
-          'nextBackendFile or nextHTTPFile is required in pikku config for nextJS'
-        )
-      }
-
-      if (nextHTTPFile && !fetchFile) {
-        throw new Error(
-          'fetchFile is required in pikku config in order for nextJS http wrapper to work'
-        )
-      }
-
-      if (nextBackendFile) {
-        const {
-          pikkuConfigFactory,
-          singletonServicesFactory,
-          sessionServicesFactory,
-        } = await getPikkuFilesAndMethods(
-          visitState,
-          packageMappings,
-          nextBackendFile,
-          options,
-          {
-            config: true,
-            singletonServicesFactory: true,
-            sessionServicesFactory: true,
-          }
-        )
-
-        const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`
-        const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`
-        const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`
-
-        const httpBootstrapPath = getFileImportRelativePath(
-          nextBackendFile,
-          bootstrapFiles.http,
-          packageMappings
-        )
-
-        const routesMapDeclarationPath = getFileImportRelativePath(
-          nextBackendFile,
-          httpRoutesMapDeclarationFile,
-          packageMappings
-        )
-
-        const content = serializeNextBackendWrapper(
-          httpBootstrapPath,
-          routesMapDeclarationPath,
-          pikkuConfigImport,
-          singletonServicesImport,
-          sessionServicesImport
-        )
-        await writeFileInDir(nextBackendFile, content)
-      }
-
-      if (nextHTTPFile && fetchFile) {
-        const routesMapDeclarationPath = getFileImportRelativePath(
-          nextHTTPFile,
-          httpRoutesMapDeclarationFile,
-          packageMappings
-        )
-
-        const fetchPath = getFileImportRelativePath(
-          nextHTTPFile,
-          fetchFile,
-          packageMappings
-        )
-
-        const content = serializeNextHTTPWrapper(
-          routesMapDeclarationPath,
-          fetchPath
-        )
-        await writeFileInDir(nextHTTPFile, content)
-      }
-    }
-  )
-}
+import { pikkuNext } from '../src/events/http/pikku-command-nextjs.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
+
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir'],
@@ -120,11 +14,12 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
     true
   )
   const visitState = await inspectorGlob(
+    logger,
     cliConfig.rootDir,
     cliConfig.srcDirectories,
     cliConfig.filters
   )
-  await pikkuNext(cliConfig, visitState, options)
+  await pikkuNext(logger, cliConfig, visitState, options)
 }
 
 export const nextjs = (program: Command): void => {

package/bin/pikku-openapi.ts

@@ -1,70 +1,23 @@
 import { Command } from 'commander'
-import {
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-import { generateSchemas } from '../src/schema-generator.js'
-import { generateOpenAPISpec } from '../src/openapi-spec-generator.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import { stringify } from 'yaml'
+import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuOpenAPI = async (
-  { tsconfig, openAPI }: PikkuCLIConfig,
-  { http, functions }: InspectorState
-) => {
-  await logCommandInfoAndTime(
-    'Creating OpenAPI spec',
-    'Created OpenAPI spec',
-    [openAPI?.outputFile === undefined, 'openAPI outfile is not defined'],
-    async () => {
-      if (!openAPI?.outputFile) {
-        throw new Error('openAPI is required')
-      }
-      const schemas = await generateSchemas(
-        tsconfig,
-        functions.typesMap,
-        functions.meta,
-        http.meta
-      )
-      const openAPISpec = await generateOpenAPISpec(
-        functions.meta,
-        http.meta,
-        schemas,
-        openAPI.additionalInfo
-      )
-      if (openAPI.outputFile.endsWith('.json')) {
-        await writeFileInDir(
-          openAPI.outputFile,
-          JSON.stringify(openAPISpec, null, 2),
-          true
-        )
-      } else if (
-        openAPI.outputFile.endsWith('.yaml') ||
-        openAPI.outputFile.endsWith('.yml')
-      ) {
-        await writeFileInDir(openAPI.outputFile, stringify(openAPISpec), true)
-      }
-    }
-  )
-}
+import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js'
 
 async function action({ config, tags }: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
   const cliConfig = await getPikkuCLIConfig(
     config,
     ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
     tags
   )
   const visitState = await inspectorGlob(
+    logger,
     cliConfig.rootDir,
     cliConfig.srcDirectories,
     cliConfig.filters
   )
-  await pikkuOpenAPI(cliConfig, visitState)
+  await pikkuOpenAPI(logger, cliConfig, visitState)
 }
 
 export const openapi = (program: Command): void => {

package/bin/pikku-queue-service.ts

@@ -0,0 +1,24 @@
+import { Command } from 'commander'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
+import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js'
+
+export const action = async (options: PikkuCLIOptions): Promise<void> => {
+  const logger = new CLILogger({ logLogo: true })
+
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    ['rootDir', 'schemaDirectory', 'configDir', 'queueFile'],
+    options.tags,
+    true
+  )
+  await pikkuQueueService(logger, cliConfig)
+}
+
+export const queue = (program: Command): void => {
+  program
+    .command('queue')
+    .description('generate queue service wrapper')
+    .option('-c | --config <string>', 'The path to pikku cli config file')
+    .action(action)
+}

package/bin/pikku-schemas.ts

@@ -1,39 +1,12 @@
 import { Command } from 'commander'
-import { saveSchemas, generateSchemas } from '../src/schema-generator.js'
 
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils/utils.js'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuSchemas = async (
-  { tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig,
-  { functions, http }: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    'Creating schemas',
-    'Created schemas',
-    [false],
-    async () => {
-      const schemas = await generateSchemas(
-        tsconfig,
-        functions.typesMap,
-        functions.meta,
-        http.meta
-      )
-      await saveSchemas(
-        schemaDirectory,
-        schemas,
-        functions.typesMap,
-        functions.meta,
-        supportsImportAttributes
-      )
-    }
-  )
-}
+import { pikkuSchemas } from '../src/schemas.js'
+import { CLILogger } from '../src/utils.js'
 
 async function action({ config }: { config?: string }): Promise<void> {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
 
   const cliConfig = await getPikkuCLIConfig(config, [
     'srcDirectories',
@@ -41,11 +14,12 @@ async function action({ config }: { config?: string }): Promise<void> {
     'tsconfig',
   ])
   const visitState = await inspectorGlob(
+    logger,
     cliConfig.rootDir,
     cliConfig.srcDirectories,
     cliConfig.filters
   )
-  await pikkuSchemas(cliConfig, visitState)
+  await pikkuSchemas(logger, cliConfig, visitState)
 }
 
 export const schemas = (program: Command): void => {