@pikku/cli 0.11.3 → 0.12.0

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

@@ -1,195 +0,0 @@
-/**
- * Generates type definitions for MCP wirings
- */
-export const serializeMCPTypes = (functionTypesImportPath: string) => {
-  return `/**
- * MCP-specific type definitions for tree-shaking optimization
- */
-
-import {
-  CoreMCPResource,
-  CoreMCPTool,
-  CoreMCPPrompt,
-  wireMCPResource as wireMCPResourceCore,
-  wireMCPTool as wireMCPToolCore,
-  wireMCPPrompt as wireMCPPromptCore,
-  MCPResourceResponse,
-  MCPToolResponse,
-  MCPPromptResponse,
-  AssertMCPResourceURIParams
-} from '@pikku/core/mcp'
-
-import type { PikkuFunctionConfig, PikkuFunctionSessionless, InferZodOutput } from '${functionTypesImportPath}'
-import type { ZodLike } from '@pikku/core'
-
-/**
- * Type definition for MCP resources that provide data to AI models.
- *
- * @template In - Input type for the resource request
- * @template URI - URI template string type for compile-time parameter validation
- */
-type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse, 'rpc' | 'session' | 'mcp'>> & { uri: URI }
-
-/**
- * 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, 'rpc' | 'session' | 'mcp'>>
-
-/**
- * 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, 'rpc' | 'session' | 'mcp'>>
-
-/**
- * Registers an MCP resource with the Pikku framework.
- * Resources provide data that AI models can access.
- *
- * @template In - Input type for the resource request
- * @template URI - URI template string for compile-time parameter validation
- * @param mcpResource - MCP resource definition with data provider function
- */
-export const wireMCPResource = <In, URI extends string>(
-  mcpResource: MCPResourceWiring<In, URI> & AssertMCPResourceURIParams<In, URI>
-) => {
-  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)
-}
-
-/**
- * Configuration for MCP prompt with Zod schema input validation.
- */
-type MCPPromptFuncConfigWithSchema<InputSchema extends ZodLike> = {
-  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
-  name?: string
-  input: InputSchema
-}
-
-/**
- * Creates a function for handling MCP prompt requests.
- * These functions generate prompt templates for AI models.
- *
- * Supports two patterns:
- * 1. Generic types: \`pikkuMCPPromptFunc<Input>({ func: ... })\`
- * 2. Zod schemas: \`pikkuMCPPromptFunc({ input: z.object(...), func: ... })\`
- *
- * @template In - Input type for the prompt parameters (inferred from schema if provided)
- * @param func - Function definition, either direct function or configuration object
- * @returns The unwrapped function for internal use
- */
-export function pikkuMCPPromptFunc<InputSchema extends ZodLike>(
-  config: MCPPromptFuncConfigWithSchema<InputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
-export function pikkuMCPPromptFunc<In>(
-  func:
-    | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
-    | {
-        func: PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
-        name?: string
-      }
-): PikkuFunctionConfig<In, MCPPromptResponse, 'mcp' | 'rpc'>
-export function pikkuMCPPromptFunc(func: any): any {
-  return typeof func === 'function' ? { func } : func
-}
-
-/**
- * Configuration for MCP tool with Zod schema input validation.
- */
-type MCPToolFuncConfigWithSchema<InputSchema extends ZodLike> = {
-  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
-  name?: string
-  input: InputSchema
-}
-
-/**
- * Creates a function for handling MCP tool invocations.
- * These functions perform actions that AI models can request.
- *
- * Supports two patterns:
- * 1. Generic types: \`pikkuMCPToolFunc<Input>({ func: ... })\`
- * 2. Zod schemas: \`pikkuMCPToolFunc({ input: z.object(...), func: ... })\`
- *
- * @template In - Input type for the tool invocation (inferred from schema if provided)
- * @param func - Function definition, either direct function or configuration object
- * @returns The unwrapped function for internal use
- */
-export function pikkuMCPToolFunc<InputSchema extends ZodLike>(
-  config: MCPToolFuncConfigWithSchema<InputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
-export function pikkuMCPToolFunc<In>(
-  func:
-    | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
-    | {
-      func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
-      name?: string
-    }
-): PikkuFunctionConfig<In, MCPToolResponse, 'mcp' | 'rpc'>
-export function pikkuMCPToolFunc(func: any): any {
-  return typeof func === 'function' ? { func } : func
-}
-
-/**
- * Configuration for MCP resource with Zod schema input validation.
- */
-type MCPResourceFuncConfigWithSchema<InputSchema extends ZodLike> = {
-  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
-  name?: string
-  input: InputSchema
-}
-
-/**
- * Creates a function for handling MCP resource requests.
- * These functions provide data that AI models can access.
- *
- * Supports two patterns:
- * 1. Generic types: \`pikkuMCPResourceFunc<Input>({ func: ... })\`
- * 2. Zod schemas: \`pikkuMCPResourceFunc({ input: z.object(...), func: ... })\`
- *
- * @template In - Input type for the resource request (inferred from schema if provided)
- * @param func - Function definition, either direct function or configuration object
- * @returns The unwrapped function for internal use
- */
-export function pikkuMCPResourceFunc<InputSchema extends ZodLike>(
-  config: MCPResourceFuncConfigWithSchema<InputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
-export function pikkuMCPResourceFunc<In>(
-  func:
-    | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
-    | {
-      func: PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
-      name?: string
-    }
-): PikkuFunctionConfig<In, MCPResourceResponse, 'mcp' | 'rpc'>
-export function pikkuMCPResourceFunc(func: any): any {
-  return typeof func === 'function' ? { func } : func
-}
-`
-}

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

@@ -1,89 +0,0 @@
-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'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-export const pikkuMiddleware: any = pikkuSessionlessFunc<
-  void,
-  boolean | undefined
->({
-  func: async ({ logger, config, getInspectorState }) => {
-    const state = await getInspectorState()
-    const { middleware } = state
-    const { middlewareFile, packageMappings, schema } = config
-
-    let filesGenerated = false
-
-    // Check if there are any middleware groups
-    const hasHTTPGroups = state.http.routeMiddleware.size > 0
-    const hasTagGroups = state.middleware.tagMiddleware.size > 0
-
-    if (hasHTTPGroups || hasTagGroups) {
-      const metaData = serializeMiddlewareGroupsMeta(state)
-
-      // Write JSON file
-      await writeFileInDir(
-        logger,
-        config.middlewareGroupsMetaJsonFile,
-        JSON.stringify(metaData, null, 2)
-      )
-
-      // Calculate relative path from TS file to JSON file
-      const jsonImportPath = getFileImportRelativePath(
-        config.middlewareGroupsMetaFile,
-        config.middlewareGroupsMetaJsonFile,
-        packageMappings
-      )
-
-      // Write TypeScript file that imports JSON
-      const supportsImportAttributes = schema?.supportsImportAttributes ?? false
-      const importStatement = supportsImportAttributes
-        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-        : `import metaData from '${jsonImportPath}'`
-
-      const packageNameValue = config.externalPackageName
-        ? `'${config.externalPackageName}'`
-        : 'null'
-
-      const tsContent = `import { pikkuState } from '@pikku/core'
-${importStatement}
-
-// HTTP middleware groups metadata
-if (metaData.httpGroups && Object.keys(metaData.httpGroups).length > 0) {
-  pikkuState(${packageNameValue}, 'middleware', 'httpGroupMeta', metaData.httpGroups)
-}
-
-// Tag middleware groups metadata
-if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
-  pikkuState(${packageNameValue}, 'middleware', 'tagGroupMeta', metaData.tagGroups)
-}
-`
-
-      await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent)
-
-      // Always generate middleware imports file when groups exist (even if empty)
-      await writeFileInDir(
-        logger,
-        middlewareFile,
-        serializeMiddlewareImports(
-          middlewareFile,
-          middleware,
-          state.http,
-          packageMappings
-        )
-      )
-
-      filesGenerated = true
-    }
-
-    return filesGenerated
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Serializing Pikku middleware',
-      commandEnd: 'Serialized Pikku middleware',
-    }),
-  ],
-})

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

@@ -1,40 +0,0 @@
-import type { InspectorState } from '@pikku/inspector'
-
-/**
- * Generates the middleware groups metadata 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) => {
-  // 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,
-    }
-  }
-
-  // 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,
-    }
-  }
-
-  return {
-    httpGroups,
-    tagGroups,
-  }
-}

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

@@ -1,78 +0,0 @@
-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/package/pikku-command-package.ts

@@ -1,81 +0,0 @@
-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 { serializePackageFactories } from './serialize-package.js'
-
-export const pikkuPackage: any = pikkuSessionlessFunc<
-  void,
-  boolean | undefined
->({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { externalPackageName, packageMappings, packageFile } = config
-
-    // Only generate for external packages
-    if (!externalPackageName) {
-      logger.info({
-        message:
-          'Skipping package factories - not an external package (externalPackageName not set)',
-        type: 'skip',
-      })
-      return false
-    }
-
-    if (!packageFile) {
-      logger.info({
-        message: 'Skipping package factories - packageFile not configured',
-        type: 'skip',
-      })
-      return false
-    }
-
-    const state = await getInspectorState()
-    const { filesAndMethods } = state
-
-    const {
-      pikkuConfigFactory,
-      singletonServicesFactory,
-      wireServicesFactory,
-    } = filesAndMethods
-
-    const content = serializePackageFactories(
-      packageFile,
-      externalPackageName,
-      pikkuConfigFactory
-        ? {
-            file: pikkuConfigFactory.file,
-            variable: pikkuConfigFactory.variable,
-          }
-        : undefined,
-      singletonServicesFactory
-        ? {
-            file: singletonServicesFactory.file,
-            variable: singletonServicesFactory.variable,
-          }
-        : undefined,
-      wireServicesFactory
-        ? {
-            file: wireServicesFactory.file,
-            variable: wireServicesFactory.variable,
-          }
-        : undefined,
-      packageMappings
-    )
-
-    if (!content) {
-      logger.info({
-        message: 'Skipping package factories - no service factories found',
-        type: 'skip',
-      })
-      return false
-    }
-
-    await writeFileInDir(logger, packageFile, content)
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating package service factories',
-      commandEnd: 'Generated package service factories',
-    }),
-  ],
-})

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

@@ -1,69 +0,0 @@
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-export interface PackageFactoryInfo {
-  file: string
-  variable: string
-}
-
-export const serializePackageFactories = (
-  outputPath: string,
-  packageName: string,
-  configFactory: PackageFactoryInfo | undefined,
-  singletonServicesFactory: PackageFactoryInfo | undefined,
-  wireServicesFactory: PackageFactoryInfo | undefined,
-  packageMappings: Record<string, string> = {}
-) => {
-  const imports: string[] = [
-    `import { addPackageServiceFactories } from '@pikku/core'`,
-  ]
-
-  const factoryEntries: string[] = []
-
-  if (configFactory) {
-    const filePath = getFileImportRelativePath(
-      outputPath,
-      configFactory.file,
-      packageMappings
-    )
-    imports.push(
-      `import { ${configFactory.variable} as createConfig } from '${filePath}'`
-    )
-    factoryEntries.push(`  createConfig,`)
-  }
-
-  if (singletonServicesFactory) {
-    const filePath = getFileImportRelativePath(
-      outputPath,
-      singletonServicesFactory.file,
-      packageMappings
-    )
-    imports.push(
-      `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${filePath}'`
-    )
-    factoryEntries.push(`  createSingletonServices,`)
-  }
-
-  if (wireServicesFactory) {
-    const filePath = getFileImportRelativePath(
-      outputPath,
-      wireServicesFactory.file,
-      packageMappings
-    )
-    imports.push(
-      `import { ${wireServicesFactory.variable} as createWireServices } from '${filePath}'`
-    )
-    factoryEntries.push(`  createWireServices,`)
-  }
-
-  // Only generate if at least one factory is defined
-  if (factoryEntries.length === 0) {
-    return null
-  }
-
-  return `${imports.join('\n')}
-
-addPackageServiceFactories('${packageName}', {
-${factoryEntries.join('\n')}
-})
-`
-}

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

@@ -1,49 +0,0 @@
-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 { serializePermissionsImports } from './serialize-permissions-imports.js'
-
-export const pikkuPermissions: any = pikkuSessionlessFunc<
-  void,
-  boolean | undefined
->({
-  func: async ({ logger, config, getInspectorState }) => {
-    const state = await getInspectorState()
-    const { permissions } = state
-    const { permissionsFile, packageMappings } = config
-
-    let filesGenerated = false
-
-    // Check if there are any permission group factories
-    const hasHTTPFactories = Array.from(
-      state.http.routePermissions.values()
-    ).some((meta: any) => meta.exportName && meta.isFactory)
-    const hasTagFactories = Array.from(
-      state.permissions.tagPermissions.values()
-    ).some((meta: any) => meta.exportName && meta.isFactory)
-    const hasFactories = hasHTTPFactories || hasTagFactories
-
-    // Generate permissions imports file if there are factories
-    if (hasFactories) {
-      await writeFileInDir(
-        logger,
-        permissionsFile,
-        serializePermissionsImports(
-          permissionsFile,
-          permissions,
-          state.http,
-          packageMappings
-        )
-      )
-      filesGenerated = true
-    }
-
-    return filesGenerated
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Serializing Pikku permissions',
-      commandEnd: 'Serialized Pikku permissions',
-    }),
-  ],
-})