@pikku/cli 0.7.7 → 0.8.1

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-functions.ts","../bin/pikku-http-map.ts","../bin/pikku-http-routes.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-rpc-map.ts","../bin/pikku-rpc.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/openapi-spec-generator.ts","../src/pikku-cli-config.ts","../src/schema-generator.ts","../src/serialize-fetch-wrapper.ts","../src/serialize-nextjs-backend-wrapper.ts","../src/serialize-nextjs-http-wrapper.ts","../src/serialize-pikku-types.ts","../src/serialize-scheduler-meta.ts","../src/serialize-typed-channel-map.ts","../src/serialize-typed-http-map.ts","../src/serialize-typed-rpc-map.ts","../src/serialize-websocket-wrapper.ts","../src/utils/serialize-import-map.ts","../src/utils/utils.ts"],"version":"5.7.3"}
+{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/pikku-command-schemas.ts","../src/schema-generator.ts","../src/schemas.ts","../src/serialize-import-map.ts","../src/serialize-pikku-types.ts","../src/types.ts","../src/utils.ts","../src/events/channels/pikku-channels.ts","../src/events/channels/pikku-command-channels-map.ts","../src/events/channels/pikku-command-channels.ts","../src/events/channels/pikku-command-websocket-typed.ts","../src/events/channels/serialize-typed-channel-map.ts","../src/events/channels/serialize-websocket-wrapper.ts","../src/events/fetch/index.ts","../src/events/functions/pikku-command-function-types.ts","../src/events/functions/pikku-command-functions.ts","../src/events/functions/pikku-command-services.ts","../src/events/functions/pikku-function-types.ts","../src/events/functions/pikku-functions.ts","../src/events/http/openapi-spec-generator.ts","../src/events/http/pikku-command-http-map.ts","../src/events/http/pikku-command-http-routes.ts","../src/events/http/pikku-command-openapi.ts","../src/events/http/pikku-http-routes.ts","../src/events/http/serialize-fetch-wrapper.ts","../src/events/http/serialize-typed-http-map.ts","../src/events/mcp/pikku-command-mcp-json.ts","../src/events/mcp/pikku-command-mcp.ts","../src/events/mcp/serialize-mcp-json.ts","../src/events/queue/pikku-command-queue-map.ts","../src/events/queue/pikku-command-queue-service.ts","../src/events/queue/pikku-command-queue.ts","../src/events/queue/pikku-queue-map.ts","../src/events/queue/pikku-queue.ts","../src/events/queue/serialize-queue-map.ts","../src/events/queue/serialize-queue-meta.ts","../src/events/queue/serialize-queue-wrapper.ts","../src/events/rpc/pikku-command-rpc-client.ts","../src/events/rpc/pikku-command-rpc-map.ts","../src/events/rpc/pikku-command-rpc.ts","../src/events/rpc/pikku-rpc.ts","../src/events/rpc/serialize-rpc-wrapper.ts","../src/events/rpc/serialize-typed-rpc-map.ts","../src/events/scheduler/pikku-command-scheduler.ts","../src/events/scheduler/serialize-scheduler-meta.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts"],"version":"5.8.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.7.7",
+  "version": "0.8.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.7.8",
-    "@pikku/inspector": "^0.7.7",
+    "@pikku/core": "^0.8.1",
+    "@pikku/inspector": "^0.8.1",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/{bin → src/events/channels}/pikku-channels.ts

@@ -1,16 +1,19 @@
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { PikkuCLIConfig } from '../../pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
 import {
   logCommandInfoAndTime,
   serializeFileImports,
   writeFileInDir,
-} from '../src/utils/utils.js'
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
 
-export const pikkuChannels = async (
+export const pikkuChannels: PikkuCommand = async (
+  logger,
   cliConfig: PikkuCLIConfig,
   visitState: InspectorState
 ) => {
   return await logCommandInfoAndTime(
+    logger,
     'Finding Channels',
     'Found channels',
     [visitState.channels.files.size === 0],
@@ -18,6 +21,7 @@ export const pikkuChannels = async (
       const { channelsFile, channelsMetaFile, packageMappings } = cliConfig
       const { channels } = visitState
       await writeFileInDir(
+        logger,
         channelsFile,
         serializeFileImports(
           'addChannel',
@@ -27,6 +31,7 @@ export const pikkuChannels = async (
         )
       )
       await writeFileInDir(
+        logger,
         channelsMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
       )

package/src/events/channels/pikku-command-channels-map.ts

@@ -0,0 +1,26 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { serializeTypedChannelsMap } from './serialize-typed-channel-map.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuChannelsMap: PikkuCommand = async (
+  logger,
+  { channelsMapDeclarationFile, packageMappings },
+  state
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating channels map',
+    'Created channels map',
+    [state.channels.files.size === 0],
+    async () => {
+      const content = serializeTypedChannelsMap(
+        channelsMapDeclarationFile,
+        packageMappings,
+        state.functions.typesMap,
+        state.functions.meta,
+        state.channels.meta
+      )
+      await writeFileInDir(logger, channelsMapDeclarationFile, content)
+    }
+  )
+}

package/src/events/channels/pikku-command-channels.ts

@@ -0,0 +1,38 @@
+import {
+  logCommandInfoAndTime,
+  serializeFileImports,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuChannels: PikkuCommand = async (
+  logger,
+  cliConfig,
+  visitState
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Finding Channels',
+    'Found channels',
+    [visitState.channels.files.size === 0],
+    async () => {
+      const { channelsFile, channelsMetaFile, packageMappings } = cliConfig
+      const { channels } = visitState
+      await writeFileInDir(
+        logger,
+        channelsFile,
+        serializeFileImports(
+          'addChannel',
+          channelsFile,
+          channels.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        logger,
+        channelsMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
+      )
+    }
+  )
+}

package/src/events/channels/pikku-command-websocket-typed.ts

@@ -0,0 +1,36 @@
+import { PikkuCommandWithoutState } from '../../types.js'
+import {
+  logCommandInfoAndTime,
+  getFileImportRelativePath,
+  writeFileInDir,
+} from '../../utils.js'
+import { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js'
+
+export const pikkuWebSocketTyped: PikkuCommandWithoutState = async (
+  logger,
+  { websocketFile, channelsMapDeclarationFile, packageMappings }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Generating websocket wrapper',
+    'Generated websocket wrapper',
+    [
+      websocketFile === undefined,
+      "websocketFile isn't set in the pikku config",
+    ],
+    async () => {
+      if (!websocketFile) {
+        throw new Error("fetchFile is isn't set in the pikku config")
+      }
+
+      const channelsMapDeclarationPath = getFileImportRelativePath(
+        websocketFile,
+        channelsMapDeclarationFile,
+        packageMappings
+      )
+
+      const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)]
+      await writeFileInDir(logger, websocketFile, content.join('\n'))
+    }
+  )
+}

package/src/{serialize-typed-channel-map.ts → events/channels/serialize-typed-channel-map.ts}

@@ -1,7 +1,7 @@
 import { ChannelsMeta } from '@pikku/core/channel'
-import { serializeImportMap } from './utils/serialize-import-map.js'
+import { serializeImportMap } from '../../serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
-import { generateCustomTypes } from './utils/utils.js'
+import { generateCustomTypes } from '../../utils.js'
 import { FunctionsMeta } from '@pikku/core'
 
 export const serializeTypedChannelsMap = (

package/src/events/fetch/index.ts

@@ -0,0 +1,33 @@
+import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js'
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommandWithoutState } from '../../types.js'
+
+export const pikkuFetch: PikkuCommandWithoutState = async (
+  logger,
+  { fetchFile, httpRoutesMapDeclarationFile, packageMappings }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    '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(logger, fetchFile, content.join('\n'))
+    }
+  )
+}

package/src/events/functions/pikku-command-function-types.ts

@@ -0,0 +1,48 @@
+import {
+  getFileImportRelativePath,
+  getPikkuFilesAndMethods,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { serializePikkuTypes } from '../../serialize-pikku-types.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuFunctionTypes: PikkuCommand = async (
+  logger,
+  { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile },
+  visitState,
+  options = {}
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating api types',
+    'Created api types',
+    [false],
+    async () => {
+      const { userSessionType, sessionServicesType, singletonServicesType } =
+        await getPikkuFilesAndMethods(
+          logger,
+          visitState,
+          packageMappings,
+          typesFile,
+          options,
+          {
+            userSessionType: true,
+            sessionServiceType: true,
+            singletonServicesType: true,
+          }
+        )
+
+      const content = serializePikkuTypes(
+        `import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`,
+        userSessionType.type,
+        `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`,
+        singletonServicesType.type,
+        `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
+        `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`
+      )
+
+      await writeFileInDir(logger, typesFile, content)
+    }
+  )
+}

package/src/events/functions/pikku-command-functions.ts

@@ -0,0 +1,84 @@
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+
+export const serializeFunctionImports = (
+  outputPath: string,
+  functionsMap: Map<string, { path: string; exportedName: string }>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedImports: string[] = [
+    `/* Import and register RPCs */`,
+    `import { addFunction } from '@pikku/core'`,
+  ]
+
+  const serializedRegistrations: string[] = []
+
+  // Sort by function name for consistent output
+  const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) =>
+    a[0].localeCompare(b[0])
+  )
+
+  for (const [name, { path, exportedName }] of sortedEntries) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      path,
+      packageMappings
+    )
+
+    // For directly exported functions, we can just import and register them
+    if (name === exportedName) {
+      serializedImports.push(`import { ${exportedName} } from '${filePath}'`)
+      serializedRegistrations.push(
+        `addFunction('${name}', { func: ${exportedName} })`
+      )
+    }
+    // For renamed functions, we need to import and alias them
+    else {
+      serializedImports.push(
+        `import { ${exportedName} as ${name} } from '${filePath}'`
+      )
+      serializedRegistrations.push(`addFunction('${name}', ${name})`)
+    }
+  }
+
+  // Add a blank line between imports and registrations
+  if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
+    serializedImports.push('')
+  }
+
+  // Combine the imports and registrations
+  return [...serializedImports, ...serializedRegistrations].join('\n')
+}
+
+export const pikkuFunctions: PikkuCommand = async (
+  logger,
+  { functionsMetaFile, functionsFile, packageMappings },
+  { functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Serializing Pikku functions',
+    'Serialized Pikku functions',
+    [false],
+    async () => {
+      await writeFileInDir(
+        logger,
+        functionsFile,
+        serializeFunctionImports(
+          functionsFile,
+          functions.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        logger,
+        functionsMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
+      )
+    }
+  )
+}

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

@@ -0,0 +1,125 @@
+import {
+  getFileImportRelativePath,
+  getPikkuFilesAndMethods,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+import { PikkuCLIConfig } from '../../pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+
+export const serializeServicesMap = (
+  functionsMetaData: Record<string, any>,
+  middlewareServices: string[] = [],
+  servicesImport: string,
+  sessionServicesImport: string
+): string => {
+  // Extract all unique services from all functions
+  const usedServices = new Set<string>()
+
+  // Internal services that are created internally and not via the create service script
+  const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession'])
+
+  for (const funcMeta of Object.values(functionsMetaData)) {
+    if (funcMeta.services && Array.isArray(funcMeta.services.services)) {
+      funcMeta.services.services.forEach((service: string) => {
+        // Only include services that are not internal
+        if (!internalServices.has(service)) {
+          usedServices.add(service)
+        }
+      })
+    }
+  }
+
+  // Add middleware services that might not be detected from function inspection
+  middlewareServices.forEach((service) => {
+    if (!internalServices.has(service)) {
+      usedServices.add(service)
+    }
+  })
+
+  // 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']
+
+  // Combine default services with detected services
+  const allRequiredServices = [
+    ...new Set([...defaultServices, ...serviceKeys]),
+  ].sort()
+
+  // 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
+
+  const code = [
+    '/**',
+    ' * This file was generated by the @pikku/cli',
+    ' */',
+    '',
+    servicesImport,
+    sessionServicesImport,
+    "import type { PikkuInteraction } from '@pikku/core'",
+    '',
+    'export const singletonServices = {',
+    ...Object.keys(servicesMap).map((service) => `    '${service}': true,`),
+    '} 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(' | ')}>>`,
+    '',
+    '// 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>`,
+    '',
+  ].join('\n')
+
+  return code
+}
+
+export const pikkuServices: PikkuCommand = async (
+  logger,
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Generating Pikku services map',
+    'Generated Pikku services map',
+    [visitState.functions.files.size === 0],
+    async () => {
+      const { sessionServicesType, singletonServicesType } =
+        await getPikkuFilesAndMethods(
+          logger,
+          visitState,
+          cliConfig.packageMappings,
+          cliConfig.typesDeclarationFile,
+          {},
+          {
+            sessionServiceType: true,
+            singletonServicesType: true,
+          }
+        )
+
+      const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, singletonServicesType.typePath, cliConfig.packageMappings)}'`
+      const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, sessionServicesType.typePath, cliConfig.packageMappings)}'`
+
+      const servicesCode = serializeServicesMap(
+        visitState.functions.meta,
+        cliConfig.middlewareServices,
+        servicesImport,
+        sessionServicesImport
+      )
+      await writeFileInDir(logger, cliConfig.servicesFile, servicesCode)
+    }
+  )
+}

package/{bin → src/events/functions}/pikku-function-types.ts

@@ -1,30 +1,27 @@
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
 import {
   getFileImportRelativePath,
   getPikkuFilesAndMethods,
   logCommandInfoAndTime,
-  PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils/utils.js'
-import { serializePikkuTypes } from '../src/serialize-pikku-types.js'
+} from '../../utils.js'
+import { serializePikkuTypes } from '../../serialize-pikku-types.js'
+import { PikkuCommand } from '../../types.js'
 
-export const pikkuFunctionTypes = async (
-  {
-    typesDeclarationFile: typesFile,
-    packageMappings,
-    rpcMapDeclarationFile,
-  }: PikkuCLIConfig,
-  options: PikkuCLIOptions,
-  visitState: InspectorState
+export const pikkuFunctionTypes: PikkuCommand = async (
+  logger,
+  { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile },
+  visitState,
+  options = {}
 ) => {
-  await logCommandInfoAndTime(
+  return await logCommandInfoAndTime(
+    logger,
     'Creating api types',
     'Created api types',
     [false],
     async () => {
       const { userSessionType, sessionServicesType, singletonServicesType } =
         await getPikkuFilesAndMethods(
+          logger,
           visitState,
           packageMappings,
           typesFile,
@@ -44,7 +41,7 @@ export const pikkuFunctionTypes = async (
         `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
         `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`
       )
-      await writeFileInDir(typesFile, content)
+      await writeFileInDir(logger, typesFile, content)
     }
   )
 }

package/{bin → src/events/functions}/pikku-functions.ts

@@ -1,10 +1,9 @@
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
 import {
   getFileImportRelativePath,
   logCommandInfoAndTime,
   writeFileInDir,
-} from '../src/utils/utils.js'
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
 
 export const serializeFunctionImports = (
   outputPath: string,
@@ -55,16 +54,19 @@ export const serializeFunctionImports = (
   return [...serializedImports, ...serializedRegistrations].join('\n')
 }
 
-export const pikkuFunctions = async (
-  { functionsMetaFile, functionsFile, packageMappings }: PikkuCLIConfig,
-  { functions }: InspectorState
+export const pikkuFunctions: PikkuCommand = async (
+  logger,
+  { functionsMetaFile, functionsFile, packageMappings },
+  { functions }
 ) => {
   return await logCommandInfoAndTime(
+    logger,
     'Serializing Pikku functions',
     'Serialized Pikku functions',
     [false],
     async () => {
       await writeFileInDir(
+        logger,
         functionsFile,
         serializeFunctionImports(
           functionsFile,
@@ -73,6 +75,7 @@ export const pikkuFunctions = async (
         )
       )
       await writeFileInDir(
+        logger,
         functionsMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
       )

package/src/events/http/pikku-command-http-map.ts

@@ -0,0 +1,27 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { serializeTypedRoutesMap } from './serialize-typed-http-map.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuHTTPMap: PikkuCommand = async (
+  logger,
+  { httpRoutesMapDeclarationFile, packageMappings },
+  { http, functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating HTTP map',
+    'Created HTTP map',
+    [http.files.size === 0],
+    async () => {
+      const content = serializeTypedRoutesMap(
+        httpRoutesMapDeclarationFile,
+        packageMappings,
+        functions.typesMap,
+        functions.meta,
+        http.meta,
+        http.metaInputTypes
+      )
+      await writeFileInDir(logger, httpRoutesMapDeclarationFile, content)
+    }
+  )
+}

package/src/events/http/pikku-command-http-routes.ts

@@ -0,0 +1,40 @@
+import { PikkuCLIConfig } from '../../pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import {
+  logCommandInfoAndTime,
+  serializeFileImports,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuHTTP: PikkuCommand = async (
+  logger,
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Finding HTTP routes',
+    'Found HTTP routes',
+    [visitState.http.files.size === 0],
+    async () => {
+      const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig
+      const { http } = visitState
+      await writeFileInDir(
+        logger,
+        httpRoutesFile,
+        serializeFileImports(
+          'addHTTPRoute',
+          httpRoutesFile,
+          http.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        logger,
+        httpRoutesMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
+      )
+    }
+  )
+}