@pikku/cli 0.9.14 → 0.9.16-next.0

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

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

package/src/{wirings → functions/wirings}/mcp/pikku-command-mcp.ts

@@ -1,9 +1,7 @@
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 import { readFile } from 'fs/promises'
 import { join } from 'path'
 
@@ -60,51 +58,62 @@ const generateArgumentsFromSchema = async (
   }
 }
 
-export const pikkuMCP: PikkuCommand = async (
-  logger,
-  { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory },
-  { mcpEndpoints, functions }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding MCP endpoints',
-    'Found MCP endpoints',
-    [mcpEndpoints.files.size === 0],
-    async () => {
-      await writeFileInDir(
-        logger,
+export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { mcpEndpoints, functions } = await getInspectorState()
+    const {
+      mcpWiringsFile,
+      mcpWiringsMetaFile,
+      packageMappings,
+      schemaDirectory,
+    } = config
+
+    await writeFileInDir(
+      logger,
+      mcpWiringsFile,
+      serializeFileImports(
+        'wireMCPResource or wireMCPTool',
         mcpWiringsFile,
-        serializeFileImports(
-          'wireMCPResource or wireMCPTool',
-          mcpWiringsFile,
-          mcpEndpoints.files,
-          packageMappings
-        )
+        mcpEndpoints.files,
+        packageMappings
       )
+    )
 
-      // Populate arguments for prompts meta before serializing
-      const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta }
-      for (const promptMeta of Object.values(promptsMetaWithArguments)) {
-        const functionMeta = functions.meta[promptMeta.pikkuFuncName]
-        if (functionMeta) {
-          const inputType = functionMeta.inputs?.[0]
-          promptMeta.arguments = await generateArgumentsFromSchema(
-            inputType || null,
-            schemaDirectory || '',
-            functions.typesMap,
-            logger
-          )
-        }
+    // Populate arguments for prompts meta before serializing
+    const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta }
+    for (const promptMeta of Object.values(promptsMetaWithArguments)) {
+      const functionMeta = functions.meta[promptMeta.pikkuFuncName]
+      if (functionMeta) {
+        const inputType = functionMeta.inputs?.[0]
+        promptMeta.arguments = await generateArgumentsFromSchema(
+          inputType || null,
+          schemaDirectory || '',
+          functions.typesMap,
+          logger
+        )
       }
+    }
 
-      await writeFileInDir(
-        logger,
-        mcpWiringsMetaFile,
-        `import { pikkuState } from '@pikku/core'
+    await writeFileInDir(
+      logger,
+      mcpWiringsMetaFile,
+      `import { pikkuState } from '@pikku/core'
 pikkuState('mcp', 'resourcesMeta', ${JSON.stringify(mcpEndpoints.resourcesMeta, null, 2)})
 pikkuState('mcp', 'toolsMeta', ${JSON.stringify(mcpEndpoints.toolsMeta, null, 2)})
 pikkuState('mcp', 'promptsMeta', ${JSON.stringify(promptsMetaWithArguments, null, 2)})`
-      )
-    }
-  )
-}
+    )
+
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding MCP endpoints',
+      commandEnd: 'Found MCP endpoints',
+      skipCondition: async ({ getInspectorState }) => {
+        const { mcpEndpoints } = await getInspectorState()
+        return mcpEndpoints.files.size === 0
+      },
+      skipMessage: 'none found',
+    }),
+  ],
+})

package/src/{wirings → functions/wirings}/mcp/serialize-mcp-json.ts

@@ -3,7 +3,7 @@ import { join } from 'path'
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core'
 import { FunctionsMeta, JSONValue } from '@pikku/core'
 import { TypesMap } from '@pikku/inspector'
-import { CLILogger } from '../../utils.js'
+import { CLILogger } from '../../../services/cli-logger.service.js'
 
 interface MCPEndpoint {
   name: string

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

@@ -0,0 +1,141 @@
+/**
+ * Generates type definitions for MCP wirings
+ */
+export const serializeMCPTypes = (functionTypesImportPath: string) => {
+  return `/**
+ * This file was generated by the @pikku/cli
+ * MCP-specific type definitions for tree-shaking optimization
+ */
+
+import {
+  CoreMCPResource,
+  CoreMCPTool,
+  CoreMCPPrompt,
+  wireMCPResource as wireMCPResourceCore,
+  wireMCPTool as wireMCPToolCore,
+  wireMCPPrompt as wireMCPPromptCore,
+  MCPResourceResponse,
+  MCPToolResponse,
+  MCPPromptResponse
+} from '@pikku/core'
+
+import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTypesImportPath}'
+
+/**
+ * Type definition for MCP resources that provide data to AI models.
+ *
+ * @template In - Input type for the resource request
+ */
+type MCPResourceWiring<In> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse>>
+
+/**
+ * Type definition for MCP tools that AI models can invoke.
+ *
+ * @template In - Input type for the tool invocation
+ */
+type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse>>
+
+/**
+ * Type definition for MCP prompts that provide templates to AI models.
+ *
+ * @template In - Input type for the prompt parameters
+ */
+type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse>>
+
+/**
+ * Registers an MCP resource with the Pikku framework.
+ * Resources provide data that AI models can access.
+ *
+ * @template In - Input type for the resource request
+ * @param mcpResource - MCP resource definition with data provider function
+ */
+export const wireMCPResource = <In>(
+  mcpResource: MCPResourceWiring<In>
+) => {
+  wireMCPResourceCore(mcpResource as any)
+}
+
+/**
+ * Registers an MCP tool with the Pikku framework.
+ * Tools are functions that AI models can invoke.
+ *
+ * @template In - Input type for the tool invocation
+ * @param mcpTool - MCP tool definition with action function
+ */
+export const wireMCPTool = <In>(
+  mcpTool: MCPToolWiring<In>
+) => {
+  wireMCPToolCore(mcpTool as any)
+}
+
+/**
+ * Registers an MCP prompt with the Pikku framework.
+ * Prompts provide templates that AI models can use.
+ *
+ * @template In - Input type for the prompt parameters
+ * @param mcpPrompt - MCP prompt definition with template function
+ */
+export const wireMCPPrompt = <In>(
+  mcpPrompt: MCPPromptWiring<In>
+) => {
+  wireMCPPromptCore(mcpPrompt as any)
+}
+
+/**
+ * Creates a function for handling MCP prompt requests.
+ * These functions generate prompt templates for AI models.
+ *
+ * @template In - Input type for the prompt parameters
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuMCPPromptFunc = <In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPPromptResponse>
+    | {
+        func: PikkuFunctionSessionless<In, MCPPromptResponse>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+/**
+ * Creates a function for handling MCP tool invocations.
+ * These functions perform actions that AI models can request.
+ *
+ * @template In - Input type for the tool invocation
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuMCPToolFunc = <In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+    | {
+      func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+      name?: string
+    }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+/**
+ * Creates a function for handling MCP resource requests.
+ * These functions provide data that AI models can access.
+ *
+ * @template In - Input type for the resource request
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuMCPResourceFunc = <In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+    | {
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+      name?: string
+    }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+`
+}

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

@@ -0,0 +1,65 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeMiddlewareImports } from './serialize-middleware-imports.js'
+import { serializeMiddlewareGroupsMeta } from './serialize-middleware-groups-meta.js'
+
+export const pikkuMiddleware: any = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const state = await getInspectorState()
+    const { middleware } = state
+    const { middlewareFile, packageMappings } = config
+
+    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
+
+    // Generate middleware imports file if there are factories
+    if (hasFactories) {
+      await writeFileInDir(
+        logger,
+        middlewareFile,
+        serializeMiddlewareImports(
+          middlewareFile,
+          middleware,
+          state.http,
+          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
+    }
+
+    return filesGenerated
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Serializing Pikku middleware',
+      commandEnd: 'Serialized Pikku middleware',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

package/src/functions/wirings/middleware/serialize-middleware-groups-meta.ts

@@ -0,0 +1,61 @@
+import type { InspectorState } from '@pikku/inspector'
+
+/**
+ * Generates the middleware groups metadata file that stores metadata about
+ * tag-based and HTTP middleware groups for visualization and inspection.
+ *
+ * This includes services, middleware count, factory status, etc.
+ */
+export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
+  const lines: string[] = [
+    `/**`,
+    ` * This file was generated by the @pikku/cli`,
+    ` */`,
+    `import { pikkuState } from '@pikku/core'`,
+    ``,
+  ]
+
+  // Serialize HTTP middleware groups metadata
+  const httpGroups: Record<string, any> = {}
+  for (const [pattern, meta] of state.http.routeMiddleware.entries()) {
+    httpGroups[pattern] = {
+      exportName: meta.exportName,
+      sourceFile: meta.sourceFile,
+      position: meta.position,
+      services: meta.services,
+      middlewareCount: meta.middlewareCount,
+      isFactory: meta.isFactory,
+    }
+  }
+
+  if (Object.keys(httpGroups).length > 0) {
+    lines.push(`// HTTP middleware groups metadata`)
+    lines.push(
+      `pikkuState('middleware', 'httpGroupMeta', ${JSON.stringify(httpGroups, null, 2)})`
+    )
+    lines.push(``)
+  }
+
+  // Serialize tag middleware groups metadata
+  const tagGroups: Record<string, any> = {}
+  for (const [tag, meta] of state.middleware.tagMiddleware.entries()) {
+    tagGroups[tag] = {
+      exportName: meta.exportName,
+      sourceFile: meta.sourceFile,
+      position: meta.position,
+      services: meta.services,
+      middlewareCount: meta.middlewareCount,
+      isFactory: meta.isFactory,
+    }
+  }
+
+  if (Object.keys(tagGroups).length > 0) {
+    lines.push(`// Tag middleware groups metadata`)
+    lines.push(
+      `pikkuState('middleware', 'tagGroupMeta', ${JSON.stringify(tagGroups, null, 2)})`
+    )
+    lines.push(``)
+  }
+
+  return lines.join('\n')
+}

package/src/functions/wirings/middleware/serialize-middleware-imports.ts

@@ -0,0 +1,78 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import type {
+  InspectorMiddlewareState,
+  InspectorHTTPState,
+  InspectorState,
+} from '@pikku/inspector'
+
+export const serializeMiddlewareImports = (
+  outputPath: string,
+  middlewareState: InspectorMiddlewareState,
+  httpState: InspectorHTTPState,
+  packageMappings: Record<string, string> = {},
+  fullState?: InspectorState
+) => {
+  const serializedImports: string[] = []
+  const serializedFactoryCalls: string[] = []
+
+  // Collect factory imports and calls for HTTP middleware groups
+  const httpFactories = new Map<
+    string,
+    { exportName: string; filePath: string }
+  >()
+  for (const [, groupMeta] of httpState.routeMiddleware.entries()) {
+    if (groupMeta.exportName && groupMeta.isFactory) {
+      const filePath = getFileImportRelativePath(
+        outputPath,
+        groupMeta.sourceFile,
+        packageMappings
+      )
+      httpFactories.set(groupMeta.exportName, {
+        exportName: groupMeta.exportName,
+        filePath,
+      })
+    }
+  }
+
+  // Collect factory imports and calls for tag middleware groups
+  const tagFactories = new Map<
+    string,
+    { exportName: string; filePath: string }
+  >()
+  for (const [, groupMeta] of middlewareState.tagMiddleware.entries()) {
+    if (groupMeta.exportName && groupMeta.isFactory) {
+      const filePath = getFileImportRelativePath(
+        outputPath,
+        groupMeta.sourceFile,
+        packageMappings
+      )
+      tagFactories.set(groupMeta.exportName, {
+        exportName: groupMeta.exportName,
+        filePath,
+      })
+    }
+  }
+
+  // Combine all factories and deduplicate by exportName (same factory might be used in multiple groups)
+  const allFactories = new Map([...httpFactories, ...tagFactories])
+
+  // Add factory imports and calls
+  if (allFactories.size > 0) {
+    serializedImports.push(
+      '/* Call middleware group factories to register at module evaluation */'
+    )
+
+    // Import factories
+    for (const [exportName, { filePath }] of allFactories) {
+      serializedImports.push(`import { ${exportName} } from '${filePath}'`)
+    }
+
+    // Call factories
+    for (const [exportName] of allFactories) {
+      serializedFactoryCalls.push(`${exportName}()`)
+    }
+  }
+
+  // Return combined output
+  return [...serializedImports, ...serializedFactoryCalls].join('\n')
+}

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

@@ -0,0 +1,31 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeQueueMap } from './serialize-queue-map.js'
+
+export const pikkuQueueMap: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { queueWorkers, functions } = await getInspectorState()
+    const { queueMapDeclarationFile, packageMappings } = config
+
+    const content = serializeQueueMap(
+      queueMapDeclarationFile,
+      packageMappings,
+      functions.typesMap,
+      functions.meta,
+      queueWorkers.meta
+    )
+    await writeFileInDir(logger, queueMapDeclarationFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating Queue map',
+      commandEnd: 'Created Queue map',
+      skipCondition: async ({ getInspectorState }) => {
+        const { queueWorkers } = await getInspectorState()
+        return queueWorkers.files.size === 0
+      },
+      skipMessage: 'none found',
+    }),
+  ],
+})

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

@@ -0,0 +1,33 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeQueueWrapper } from './serialize-queue-wrapper.js'
+
+export const pikkuQueueService: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const { queueWiringsFile, queueMapDeclarationFile, packageMappings } =
+      config
+
+    if (!queueWiringsFile) {
+      throw new Error("queueWiringsFile is isn't set in the pikku config")
+    }
+
+    const queueMapDeclarationPath = getFileImportRelativePath(
+      queueWiringsFile,
+      queueMapDeclarationFile,
+      packageMappings
+    )
+
+    const content = [serializeQueueWrapper(queueMapDeclarationPath)]
+    await writeFileInDir(logger, queueWiringsFile, content.join('\n'))
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating queue service wrapper',
+      commandEnd: 'Generated queue service wrapper',
+      skipCondition: ({ config }) => config.queueWiringsFile === undefined,
+      skipMessage: "queueWiringsFile isn't set in the pikku config",
+    }),
+  ],
+})

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

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

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

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

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

@@ -0,0 +1,31 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeQueueMap } from './serialize-queue-map.js'
+
+export const pikkuQueueMap: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { queueWorkers, functions } = await getInspectorState()
+    const { queueMapDeclarationFile, packageMappings } = config
+
+    const content = serializeQueueMap(
+      queueMapDeclarationFile,
+      packageMappings,
+      functions.typesMap,
+      functions.meta,
+      queueWorkers.meta
+    )
+    await writeFileInDir(logger, queueMapDeclarationFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating Queue map',
+      commandEnd: 'Created Queue map',
+      skipCondition: async ({ getInspectorState }) => {
+        const { queueWorkers } = await getInspectorState()
+        return queueWorkers.files.size === 0
+      },
+      skipMessage: 'none found',
+    }),
+  ],
+})