@pikku/cli 0.8.3 → 0.9.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @pikku/cli
 
+## 0.9.1
+
+### Patch Changes
+
+- fdb1593: feat: adding silent option to cli
+- fdb1593: core: bumping everything with a patch to sync up the major release inconsistencies in dependencies
+- Updated dependencies [fdb1593]
+  - @pikku/core@0.9.1
+  - @pikku/inspector@0.9.1
+
+## 0.9.0
+
+### Breaking Changes
+
+- Normalized all transports to use "wirings" instead of events/routes/transports for consistency across the framework
+
 ## 0.8.3
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -6,29 +6,29 @@ import {
   writeFileInDir,
 } from '../src/utils.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.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 { pikkuHTTP } from '../src/wirings/http/pikku-command-http-routes.js'
+import { pikkuFunctionTypes } from '../src/wirings/functions/pikku-command-function-types.js'
+import { pikkuHTTPMap } from '../src/wirings/http/pikku-command-http-map.js'
 import { existsSync } from 'fs'
-import { pikkuChannelsMap } from '../src/events/channels/pikku-command-channels-map.js'
-import { pikkuChannels } from '../src/events/channels/pikku-command-channels.js'
+import { pikkuChannelsMap } from '../src/wirings/channels/pikku-command-channels-map.js'
+import { pikkuChannels } from '../src/wirings/channels/pikku-command-channels.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 import chokidar from 'chokidar'
-import { pikkuFunctions } from '../src/events/functions/pikku-command-functions.js'
-import { pikkuServices } from '../src/events/functions/pikku-command-services.js'
-import { pikkuRPC } from '../src/events/rpc/pikku-command-rpc.js'
-import { pikkuRPCMap } from '../src/events/rpc/pikku-command-rpc-map.js'
-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 { pikkuRPCClient } from '../src/events/rpc/pikku-command-rpc-client.js'
-import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.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 { pikkuFunctions } from '../src/wirings/functions/pikku-command-functions.js'
+import { pikkuServices } from '../src/wirings/functions/pikku-command-services.js'
+import { pikkuRPC } from '../src/wirings/rpc/pikku-command-rpc.js'
+import { pikkuRPCMap } from '../src/wirings/rpc/pikku-command-rpc-map.js'
+import { pikkuQueue } from '../src/wirings/queue/pikku-command-queue.js'
+import { pikkuQueueMap } from '../src/wirings/queue/pikku-command-queue-map.js'
+import { pikkuFetch } from '../src/wirings/fetch/index.js'
+import { pikkuRPCClient } from '../src/wirings/rpc/pikku-command-rpc-client.js'
+import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js'
+import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js'
+import { pikkuMCP } from '../src/wirings/mcp/pikku-command-mcp.js'
+import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js'
+import { pikkuScheduler } from '../src/wirings/scheduler/pikku-command-scheduler.js'
 import { pikkuSchemas } from '../src/schemas.js'
-import { pikkuMCPJSON } from '../src/events/mcp/pikku-command-mcp-json.js'
+import { pikkuMCPJSON } from '../src/wirings/mcp/pikku-command-mcp-json.js'
 import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js'
 
 const generateBootstrapFile = async (
@@ -82,7 +82,7 @@ const runAll = async (
   }
   await pikkuFunctionTypes(logger, cliConfig, visitState, options)
 
-  // This is needed since the addHTTPRoute function will add the routes to the visitState
+  // This is needed since the wireHTTP function will add the routes to the visitState
   if (!typesDeclarationFileExists) {
     logger.info(`• Type file first created, inspecting again...\x1b[0m`)
     visitState = await inspectorGlob(
@@ -108,7 +108,7 @@ const runAll = async (
   await pikkuRPC(logger, cliConfig, visitState)
   await pikkuRPCMap(logger, cliConfig, visitState)
   await pikkuRPCClient(logger, cliConfig)
-  allImports.push(cliConfig.rpcMetaFile)
+  allImports.push(cliConfig.rpcWiringMetaFile)
 
   const schemas = await pikkuSchemas(logger, cliConfig, visitState)
   if (schemas) {
@@ -120,7 +120,7 @@ const runAll = async (
     logger,
     cliConfig,
     cliConfig.bootstrapFiles.rpc,
-    [cliConfig.rpcMetaFile],
+    [cliConfig.rpcWiringMetaFile],
     schemas
   )
 
@@ -128,26 +128,29 @@ const runAll = async (
   if (http) {
     await pikkuHTTPMap(logger, cliConfig, visitState)
     await pikkuFetch(logger, cliConfig)
-    allImports.push(cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile)
+    allImports.push(cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile)
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.http,
-      [cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile],
+      [cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile],
       schemas
     )
   }
 
   const scheduler = await pikkuScheduler(logger, cliConfig, visitState)
   if (scheduler) {
-    allImports.push(cliConfig.schedulersMetaFile, cliConfig.schedulersFile)
+    allImports.push(
+      cliConfig.schedulersWiringMetaFile,
+      cliConfig.schedulersWiringFile
+    )
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.scheduler,
-      [cliConfig.schedulersMetaFile, cliConfig.schedulersFile],
+      [cliConfig.schedulersWiringMetaFile, cliConfig.schedulersWiringFile],
       schemas
     )
   }
@@ -156,13 +159,16 @@ const runAll = async (
   if (queues) {
     await pikkuQueueMap(logger, cliConfig, visitState)
     await pikkuQueueService(logger, cliConfig)
-    allImports.push(cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile)
+    allImports.push(
+      cliConfig.queueWorkersWiringMetaFile,
+      cliConfig.queueWorkersWiringFile
+    )
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.queue,
-      [cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile],
+      [cliConfig.queueWorkersWiringMetaFile, cliConfig.queueWorkersWiringFile],
       schemas
     )
   }
@@ -171,13 +177,16 @@ const runAll = async (
   if (channels) {
     await pikkuChannelsMap(logger, cliConfig, visitState)
     await pikkuWebSocketTyped(logger, cliConfig)
-    allImports.push(cliConfig.channelsMetaFile, cliConfig.channelsFile)
+    allImports.push(
+      cliConfig.channelsWiringMetaFile,
+      cliConfig.channelsWiringFile
+    )
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.channel,
-      [cliConfig.channelsMetaFile, cliConfig.channelsFile],
+      [cliConfig.channelsWiringMetaFile, cliConfig.channelsWiringFile],
       schemas
     )
   }
@@ -185,13 +194,13 @@ const runAll = async (
   const mcp = await pikkuMCP(logger, cliConfig, visitState)
   if (mcp) {
     await pikkuMCPJSON(logger, cliConfig, visitState)
-    allImports.push(cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile)
+    allImports.push(cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile)
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.mcp,
-      [cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile],
+      [cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile],
       schemas
     )
   }
@@ -253,7 +262,11 @@ const watch = (
     watcher.on('ready', async () => {
       const handle = async () => {
         try {
+          const start = Date.now()
           await runAll(logger, cliConfig, options)
+          if (options.silent) {
+            logger.timing(`✓ Generated in ${Date.now() - start}ms`)
+          }
         } catch (err) {
           console.error(err)
           console.info()
@@ -282,7 +295,7 @@ const watch = (
 }
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  const logger = new CLILogger({ logLogo: true })
+  const logger = new CLILogger({ logLogo: true, silent: options.silent })
 
   const cliConfig = await getPikkuCLIConfig(
     options.config,
@@ -323,5 +336,6 @@ export const all = (program: Command): void => {
     )
     .option('--directories <directories...>', 'Which directories to filter by')
     .option('-w | --watch', 'Whether to watch file changes')
+    .option('-s | --silent', 'Silent mode - only show errors')
     .action(action)
 }

package/bin/pikku-fetch.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuFetch } from '../src/events/fetch/index.js'
+import { pikkuFetch } from '../src/wirings/fetch/index.js'
 import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {

package/bin/pikku-openapi.ts

@@ -2,13 +2,13 @@ import { Command } from 'commander'
 import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
-import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js'
+import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js'
 
 async function action({ config, tags }: PikkuCLIOptions): Promise<void> {
   const logger = new CLILogger({ logLogo: true })
   const cliConfig = await getPikkuCLIConfig(
     config,
-    ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
+    ['rootDir', 'httpWiringsFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
     {
       tags: tags || [],
     }

package/bin/pikku-queue-service.ts

@@ -1,14 +1,14 @@
 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'
+import { pikkuQueueService } from '../src/wirings/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'],
+    ['rootDir', 'schemaDirectory', 'configDir', 'queueWiringsFile'],
     {
       tags: options.tags,
       types: options.types,

package/bin/pikku-websocket.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander'
 import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js'
+import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const logger = new CLILogger({ logLogo: true })

package/cli.schema.json

@@ -172,13 +172,13 @@
           "required": ["http", "scheduler", "channel", "rpc", "queue", "mcp"],
           "type": "object"
         },
-        "channelsFile": {
+        "channelsMapDeclarationFile": {
           "type": "string"
         },
-        "channelsMapDeclarationFile": {
+        "channelsWiringFile": {
           "type": "string"
         },
-        "channelsMetaFile": {
+        "channelsWiringMetaFile": {
           "type": "string"
         },
         "configDir": {
@@ -199,22 +199,22 @@
         "functionsMetaFile": {
           "type": "string"
         },
-        "httpRoutesFile": {
+        "httpMapDeclarationFile": {
           "type": "string"
         },
-        "httpRoutesMapDeclarationFile": {
+        "httpWiringMetaFile": {
           "type": "string"
         },
-        "httpRoutesMetaFile": {
+        "httpWiringsFile": {
           "type": "string"
         },
-        "mcpEndpointsFile": {
+        "mcpJsonFile": {
           "type": "string"
         },
-        "mcpEndpointsMetaFile": {
+        "mcpWiringsFile": {
           "type": "string"
         },
-        "mcpJsonFile": {
+        "mcpWiringsMetaFile": {
           "type": "string"
         },
         "middlewareServices": {
@@ -251,34 +251,34 @@
           },
           "type": "object"
         },
-        "queueFile": {
+        "queueMapDeclarationFile": {
           "type": "string"
         },
-        "queueMapDeclarationFile": {
+        "queueWiringsFile": {
           "type": "string"
         },
-        "queueWorkersFile": {
+        "queueWorkersWiringFile": {
           "type": "string"
         },
-        "queueWorkersMetaFile": {
+        "queueWorkersWiringMetaFile": {
           "type": "string"
         },
         "rootDir": {
           "type": "string"
         },
-        "rpcFile": {
+        "rpcMapDeclarationFile": {
           "type": "string"
         },
-        "rpcMapDeclarationFile": {
+        "rpcWiringMetaFile": {
           "type": "string"
         },
-        "rpcMetaFile": {
+        "rpcWiringsFile": {
           "type": "string"
         },
-        "schedulersFile": {
+        "schedulersWiringFile": {
           "type": "string"
         },
-        "schedulersMetaFile": {
+        "schedulersWiringMetaFile": {
           "type": "string"
         },
         "schemaDirectory": {
@@ -309,27 +309,27 @@
       "required": [
         "bootstrapFile",
         "bootstrapFiles",
-        "channelsFile",
         "channelsMapDeclarationFile",
-        "channelsMetaFile",
+        "channelsWiringFile",
+        "channelsWiringMetaFile",
         "configDir",
         "filters",
         "functionsFile",
         "functionsMetaFile",
-        "httpRoutesFile",
-        "httpRoutesMapDeclarationFile",
-        "httpRoutesMetaFile",
-        "mcpEndpointsFile",
-        "mcpEndpointsMetaFile",
+        "httpMapDeclarationFile",
+        "httpWiringMetaFile",
+        "httpWiringsFile",
+        "mcpWiringsFile",
+        "mcpWiringsMetaFile",
         "packageMappings",
         "queueMapDeclarationFile",
-        "queueWorkersFile",
-        "queueWorkersMetaFile",
+        "queueWorkersWiringFile",
+        "queueWorkersWiringMetaFile",
         "rootDir",
         "rpcMapDeclarationFile",
-        "rpcMetaFile",
-        "schedulersFile",
-        "schedulersMetaFile",
+        "rpcWiringMetaFile",
+        "schedulersWiringFile",
+        "schedulersWiringMetaFile",
         "schemaDirectory",
         "servicesFile",
         "srcDirectories",

package/dist/bin/pikku-all.js

@@ -1,28 +1,28 @@
 import { CLILogger, getFileImportRelativePath, writeFileInDir, } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.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 { pikkuHTTP } from '../src/wirings/http/pikku-command-http-routes.js';
+import { pikkuFunctionTypes } from '../src/wirings/functions/pikku-command-function-types.js';
+import { pikkuHTTPMap } from '../src/wirings/http/pikku-command-http-map.js';
 import { existsSync } from 'fs';
-import { pikkuChannelsMap } from '../src/events/channels/pikku-command-channels-map.js';
-import { pikkuChannels } from '../src/events/channels/pikku-command-channels.js';
+import { pikkuChannelsMap } from '../src/wirings/channels/pikku-command-channels-map.js';
+import { pikkuChannels } from '../src/wirings/channels/pikku-command-channels.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 import chokidar from 'chokidar';
-import { pikkuFunctions } from '../src/events/functions/pikku-command-functions.js';
-import { pikkuServices } from '../src/events/functions/pikku-command-services.js';
-import { pikkuRPC } from '../src/events/rpc/pikku-command-rpc.js';
-import { pikkuRPCMap } from '../src/events/rpc/pikku-command-rpc-map.js';
-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 { pikkuRPCClient } from '../src/events/rpc/pikku-command-rpc-client.js';
-import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.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 { pikkuFunctions } from '../src/wirings/functions/pikku-command-functions.js';
+import { pikkuServices } from '../src/wirings/functions/pikku-command-services.js';
+import { pikkuRPC } from '../src/wirings/rpc/pikku-command-rpc.js';
+import { pikkuRPCMap } from '../src/wirings/rpc/pikku-command-rpc-map.js';
+import { pikkuQueue } from '../src/wirings/queue/pikku-command-queue.js';
+import { pikkuQueueMap } from '../src/wirings/queue/pikku-command-queue-map.js';
+import { pikkuFetch } from '../src/wirings/fetch/index.js';
+import { pikkuRPCClient } from '../src/wirings/rpc/pikku-command-rpc-client.js';
+import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js';
+import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js';
+import { pikkuMCP } from '../src/wirings/mcp/pikku-command-mcp.js';
+import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js';
+import { pikkuScheduler } from '../src/wirings/scheduler/pikku-command-scheduler.js';
 import { pikkuSchemas } from '../src/schemas.js';
-import { pikkuMCPJSON } from '../src/events/mcp/pikku-command-mcp-json.js';
+import { pikkuMCPJSON } from '../src/wirings/mcp/pikku-command-mcp-json.js';
 import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js';
 const generateBootstrapFile = async (logger, cliConfig, bootstrapFile, specificImports, schemas) => {
     // Common imports that every bootstrap file needs
@@ -46,7 +46,7 @@ const runAll = async (logger, cliConfig, options) => {
         typesDeclarationFileExists = false;
     }
     await pikkuFunctionTypes(logger, cliConfig, visitState, options);
-    // This is needed since the addHTTPRoute function will add the routes to the visitState
+    // This is needed since the wireHTTP function will add the routes to the visitState
     if (!typesDeclarationFileExists) {
         logger.info(`• Type file first created, inspecting again...\x1b[0m`);
         visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
@@ -63,44 +63,44 @@ const runAll = async (logger, cliConfig, options) => {
     await pikkuRPC(logger, cliConfig, visitState);
     await pikkuRPCMap(logger, cliConfig, visitState);
     await pikkuRPCClient(logger, cliConfig);
-    allImports.push(cliConfig.rpcMetaFile);
+    allImports.push(cliConfig.rpcWiringMetaFile);
     const schemas = await pikkuSchemas(logger, cliConfig, visitState);
     if (schemas) {
         allImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`);
     }
     // RPC bootstrap is always generated since RPC is always present
-    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [cliConfig.rpcMetaFile], schemas);
+    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [cliConfig.rpcWiringMetaFile], schemas);
     const http = await pikkuHTTP(logger, cliConfig, visitState);
     if (http) {
         await pikkuHTTPMap(logger, cliConfig, visitState);
         await pikkuFetch(logger, cliConfig);
-        allImports.push(cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.http, [cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile], schemas);
+        allImports.push(cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.http, [cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile], schemas);
     }
     const scheduler = await pikkuScheduler(logger, cliConfig, visitState);
     if (scheduler) {
-        allImports.push(cliConfig.schedulersMetaFile, cliConfig.schedulersFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.scheduler, [cliConfig.schedulersMetaFile, cliConfig.schedulersFile], schemas);
+        allImports.push(cliConfig.schedulersWiringMetaFile, cliConfig.schedulersWiringFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.scheduler, [cliConfig.schedulersWiringMetaFile, cliConfig.schedulersWiringFile], schemas);
     }
     const queues = await pikkuQueue(logger, cliConfig, visitState);
     if (queues) {
         await pikkuQueueMap(logger, cliConfig, visitState);
         await pikkuQueueService(logger, cliConfig);
-        allImports.push(cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.queue, [cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile], schemas);
+        allImports.push(cliConfig.queueWorkersWiringMetaFile, cliConfig.queueWorkersWiringFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.queue, [cliConfig.queueWorkersWiringMetaFile, cliConfig.queueWorkersWiringFile], schemas);
     }
     const channels = await pikkuChannels(logger, cliConfig, visitState);
     if (channels) {
         await pikkuChannelsMap(logger, cliConfig, visitState);
         await pikkuWebSocketTyped(logger, cliConfig);
-        allImports.push(cliConfig.channelsMetaFile, cliConfig.channelsFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.channel, [cliConfig.channelsMetaFile, cliConfig.channelsFile], schemas);
+        allImports.push(cliConfig.channelsWiringMetaFile, cliConfig.channelsWiringFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.channel, [cliConfig.channelsWiringMetaFile, cliConfig.channelsWiringFile], schemas);
     }
     const mcp = await pikkuMCP(logger, cliConfig, visitState);
     if (mcp) {
         await pikkuMCPJSON(logger, cliConfig, visitState);
-        allImports.push(cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.mcp, [cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile], schemas);
+        allImports.push(cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.mcp, [cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile], schemas);
     }
     if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
         await pikkuNext(logger, cliConfig, visitState, options);
@@ -132,7 +132,11 @@ const watch = (logger, cliConfig, options) => {
         watcher.on('ready', async () => {
             const handle = async () => {
                 try {
+                    const start = Date.now();
                     await runAll(logger, cliConfig, options);
+                    if (options.silent) {
+                        logger.timing(`✓ Generated in ${Date.now() - start}ms`);
+                    }
                 }
                 catch (err) {
                     console.error(err);
@@ -156,7 +160,7 @@ const watch = (logger, cliConfig, options) => {
     configWatcher.on('change', generatorWatcher);
 };
 export const action = async (options) => {
-    const logger = new CLILogger({ logLogo: true });
+    const logger = new CLILogger({ logLogo: true, silent: options.silent });
     const cliConfig = await getPikkuCLIConfig(options.config, [], {
         tags: options.tags,
         types: options.types,
@@ -181,5 +185,6 @@ export const all = (program) => {
         .option('--types <types...>', 'Which types to filter by (http, channel, queue, scheduler, rpc, mcp)')
         .option('--directories <directories...>', 'Which directories to filter by')
         .option('-w | --watch', 'Whether to watch file changes')
+        .option('-s | --silent', 'Silent mode - only show errors')
         .action(action);
 };

package/dist/bin/pikku-fetch.js

@@ -1,5 +1,5 @@
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuFetch } from '../src/events/fetch/index.js';
+import { pikkuFetch } from '../src/wirings/fetch/index.js';
 import { CLILogger } from '../src/utils.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });

package/dist/bin/pikku-openapi.js

@@ -1,10 +1,10 @@
 import { CLILogger } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js';
+import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js';
 async function action({ config, tags }) {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'], {
+    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'httpWiringsFile', 'openAPI', 'schemaDirectory', 'tsconfig'], {
         tags: tags || [],
     });
     const visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);

package/dist/bin/pikku-queue-service.js

@@ -1,9 +1,9 @@
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { CLILogger } from '../src/utils.js';
-import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js';
+import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'queueFile'], {
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'queueWiringsFile'], {
         tags: options.tags,
         types: options.types,
         directories: options.directories,

package/dist/bin/pikku-websocket.js

@@ -1,6 +1,6 @@
 import { CLILogger } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js';
+import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });
     const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], {

package/dist/src/inspector-glob.js

@@ -5,8 +5,8 @@ import { logCommandInfoAndTime } from './utils.js';
 export const inspectorGlob = async (logger, rootDir, srcDirectories, filters) => {
     let result;
     await logCommandInfoAndTime(logger, 'Inspecting codebase', 'Inspected codebase', [false], async () => {
-        const routeFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
-        result = await inspect(logger, routeFiles, filters);
+        const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
+        result = await inspect(logger, wiringFiles, filters);
     });
     return result;
 };