@pikku/cli 0.11.2 → 0.12.0

package/src/functions/wirings/http/serialize-typed-http-map.ts

@@ -1,154 +0,0 @@
-import { HTTPWiringsMeta } from '@pikku/core/http'
-import { serializeImportMap } from '../../../utils/serialize-import-map.js'
-import { MetaInputTypes, TypesMap } from '@pikku/inspector'
-import { FunctionsMeta } from '@pikku/core'
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
-
-export const serializeTypedHTTPWiringsMap = (
-  relativeToPath: string,
-  packageMappings: Record<string, string>,
-  typesMap: TypesMap,
-  functionsMeta: FunctionsMeta,
-  wiringsMeta: HTTPWiringsMeta,
-  metaTypes: MetaInputTypes
-) => {
-  const requiredTypes = new Set<string>()
-  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
-  const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
-  const serializedHTTPWirings = generateHTTPWirings(
-    wiringsMeta,
-    functionsMeta,
-    typesMap,
-    requiredTypes
-  )
-
-  const serializedImportMap = serializeImportMap(
-    relativeToPath,
-    packageMappings,
-    typesMap,
-    requiredTypes
-  )
-
-  return `/**
- * This provides the structure needed for typescript to be aware of routes and their return types
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-${serializedMetaTypes}
-
-interface HTTPWiringHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedHTTPWirings}
-
-export type HTTPWiringHandlerOf<HTTPWiring extends keyof HTTPWiringsMap, Method extends keyof HTTPWiringsMap[HTTPWiring]> =
-    HTTPWiringsMap[HTTPWiring][Method] extends { input: infer I; output: infer O }
-        ? HTTPWiringHandler<I, O>
-        : never;
-
-export type HTTPWiringsWithMethod<Method extends string> = {
-  [HTTPWiring in keyof HTTPWiringsMap]: Method extends keyof HTTPWiringsMap[HTTPWiring] ? HTTPWiring : never;
-}[keyof HTTPWiringsMap];
-  `
-}
-
-function generateHTTPWirings(
-  routesMeta: HTTPWiringsMeta,
-  functionsMeta: FunctionsMeta,
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  // Initialize an object to collect routes
-  const routesObj: Record<
-    string,
-    Record<string, { inputType: string; outputType: string }>
-  > = {}
-
-  for (const methods of Object.values(routesMeta)) {
-    for (const meta of Object.values(methods)) {
-      const { route, method, pikkuFuncName } = meta
-      const functionMeta = functionsMeta[pikkuFuncName]
-      if (!functionMeta) {
-        throw new Error(
-          `Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`
-        )
-      }
-      const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
-      const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
-
-      // Initialize the route entry if it doesn't exist
-      if (!routesObj[route]) {
-        routesObj[route] = {}
-      }
-
-      // Store the input and output types separately for RouteHandler
-      const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
-      const outputType = output
-        ? typesMap.getTypeMeta(output).uniqueName
-        : 'null'
-
-      requiredTypes.add(inputType)
-      requiredTypes.add(outputType)
-
-      // Add method entry
-      routesObj[route][method] = {
-        inputType,
-        outputType,
-      }
-    }
-  }
-
-  // Build the routes object as a string
-  let routesStr = 'export type HTTPWiringsMap = {\n'
-
-  for (const [routePath, methods] of Object.entries(routesObj)) {
-    routesStr += `  readonly '${routePath}': {\n`
-    for (const [method, handler] of Object.entries(methods)) {
-      routesStr += `    readonly ${method.toUpperCase()}: HTTPWiringHandler<${handler.inputType}, ${handler.outputType}>,\n`
-    }
-    routesStr += '  },\n'
-  }
-
-  routesStr += '};'
-
-  return routesStr
-}
-
-const generateMetaTypes = (metaTypes: MetaInputTypes, typesMap: TypesMap) => {
-  const nameToTypeMap = Array.from(metaTypes.entries()).reduce<
-    Map<string, string>
-  >((result, [_name, { query, body, params }]) => {
-    const { uniqueName } = typesMap.getTypeMeta(_name)
-    const queryType =
-      query && query.length > 0
-        ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
-        : undefined
-    if (queryType) {
-      result.set(`${uniqueName}Query`, queryType)
-    }
-    const paramsType =
-      params && params.length > 0
-        ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
-        : undefined
-    if (paramsType) {
-      result.set(`${uniqueName}Params`, paramsType)
-    }
-    const bodyType =
-      (body && body.length > 0) || (params && params.length > 0)
-        ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
-        : uniqueName!
-    if (bodyType) {
-      result.set(`${uniqueName}Body`, bodyType)
-    }
-    return result
-  }, new Map())
-
-  return `
-// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
-${Array.from(nameToTypeMap.entries())
-  .map(([name, type]) => `export type ${name} = ${type} & {}`)
-  .join('\n')}`
-}

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

@@ -1,33 +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 { serializeMCPJson } from './serialize-mcp-json.js'
-
-export const pikkuMCPJSON: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { mcpEndpoints, functions } = await getInspectorState()
-    const { mcpJsonFile, schemaDirectory } = config
-
-    // Generate MCP JSON file
-    if (mcpJsonFile) {
-      const mcpJson = await serializeMCPJson(
-        logger,
-        schemaDirectory,
-        functions.meta,
-        functions.typesMap,
-        mcpEndpoints.resourcesMeta,
-        mcpEndpoints.toolsMeta,
-        mcpEndpoints.promptsMeta
-      )
-      await writeFileInDir(logger, mcpJsonFile, mcpJson, {
-        ignoreModifyComment: true,
-      })
-    }
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating MCP JSON',
-      commandEnd: 'Generated MCP JSON',
-    }),
-  ],
-})

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

@@ -1,25 +0,0 @@
-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',
-    }),
-  ],
-})

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

@@ -1,140 +0,0 @@
-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'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-// Helper function to generate arguments from schema
-const generateArgumentsFromSchema = async (
-  inputSchema: string | null,
-  schemaDirectory: string,
-  typesMap: any,
-  logger: any
-): Promise<Array<{ name: string; description: string; required: boolean }>> => {
-  if (!inputSchema) return []
-
-  if (
-    ['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(
-      inputSchema
-    )
-  ) {
-    return []
-  }
-
-  const uniqueName = typesMap.getUniqueName(inputSchema)
-  if (!uniqueName) return []
-
-  try {
-    const schemaPath = join(
-      schemaDirectory,
-      'schemas',
-      `${uniqueName}.schema.json`
-    )
-    const schemaContent = await readFile(schemaPath, 'utf-8')
-    const schema = JSON.parse(schemaContent)
-
-    const argumentsArray: Array<{
-      name: string
-      description: string
-      required: boolean
-    }> = []
-    if (schema && typeof schema === 'object' && schema.properties) {
-      const properties = schema.properties as Record<string, any>
-      const required = (schema.required as string[]) || []
-
-      for (const [propName, propSchema] of Object.entries(properties)) {
-        argumentsArray.push({
-          name: propName,
-          description: propSchema.description || `${propName} parameter`,
-          required: required.includes(propName),
-        })
-      }
-    }
-    return argumentsArray
-  } catch (e) {
-    logger.warn(`Could not load schema for type: ${uniqueName}`)
-    return []
-  }
-}
-
-export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { mcpEndpoints, functions } = await getInspectorState()
-    const {
-      mcpWiringsFile,
-      mcpWiringsMetaFile,
-      packageMappings,
-      schemaDirectory,
-      schema,
-    } = config
-
-    await writeFileInDir(
-      logger,
-      mcpWiringsFile,
-      serializeFileImports(
-        'wireMCPResource or wireMCPTool',
-        mcpWiringsFile,
-        mcpEndpoints.files,
-        packageMappings
-      )
-    )
-
-    // Populate arguments for prompts meta before serializing
-    const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta }
-    for (const promptMeta of Object.values(promptsMetaWithArguments) as any[]) {
-      const functionMeta = functions.meta[promptMeta.pikkuFuncName]
-      if (functionMeta) {
-        const inputType = functionMeta.inputs?.[0]
-        promptMeta.arguments = await generateArgumentsFromSchema(
-          inputType || null,
-          schemaDirectory || '',
-          functions.typesMap,
-          logger
-        )
-      }
-    }
-
-    const metaData = {
-      resourcesMeta: mcpEndpoints.resourcesMeta,
-      toolsMeta: mcpEndpoints.toolsMeta,
-      promptsMeta: promptsMetaWithArguments,
-    }
-    await writeFileInDir(
-      logger,
-      config.mcpWiringsMetaJsonFile,
-      JSON.stringify(metaData, null, 2)
-    )
-
-    const jsonImportPath = getFileImportRelativePath(
-      mcpWiringsMetaFile,
-      config.mcpWiringsMetaJsonFile,
-      packageMappings
-    )
-
-    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
-    const importStatement = supportsImportAttributes
-      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-      : `import metaData from '${jsonImportPath}'`
-
-    await writeFileInDir(
-      logger,
-      mcpWiringsMetaFile,
-      `import { pikkuState } from '@pikku/core'
-import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
-${importStatement}
-pikkuState('mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)
-pikkuState('mcp', 'toolsMeta', metaData.toolsMeta as MCPToolMeta)
-pikkuState('mcp', 'promptsMeta', metaData.promptsMeta as MCPPromptMeta)`
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding MCP endpoints',
-      commandEnd: 'Found MCP endpoints',
-    }),
-  ],
-})

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

@@ -1,159 +0,0 @@
-import { readFile } from 'fs/promises'
-import { join } from 'path'
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
-import { FunctionsMeta, JSONValue } from '@pikku/core'
-import { TypesMap } from '@pikku/inspector'
-import { CLILogger } from '../../../services/cli-logger.service.js'
-
-interface MCPEndpoint {
-  name: string
-  description?: string
-  parameters?: JSONValue
-  returns?: JSONValue
-  streaming?: boolean
-}
-
-export const serializeMCPJson = async (
-  logger: CLILogger,
-  schemaDirectory: string,
-  functionsMeta: FunctionsMeta,
-  typesMap: TypesMap,
-  mcpResourceMeta: MCPResourceMeta,
-  mcpToolMeta: MCPToolMeta,
-  mcpPromptMeta: MCPPromptMeta
-): Promise<string> => {
-  const tools: MCPEndpoint[] = []
-  const resources: MCPEndpoint[] = []
-  const prompts: any[] = []
-
-  // Helper function to load schema from file
-  const loadSchema = async (
-    typeName: string | undefined
-  ): Promise<JSONValue | undefined> => {
-    if (
-      !typeName ||
-      ['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(
-        typeName
-      )
-    ) {
-      return undefined
-    }
-
-    const uniqueName = typesMap.getUniqueName(typeName)
-    if (!uniqueName) {
-      return undefined
-    }
-
-    try {
-      const schemaPath = join(
-        schemaDirectory,
-        'schemas',
-        `${uniqueName}.schema.json`
-      )
-      const schemaContent = await readFile(schemaPath, 'utf-8')
-      return JSON.parse(schemaContent)
-    } catch (e) {
-      logger.warn(`Could not load schema for type: ${uniqueName}`)
-      return undefined
-    }
-  }
-
-  // Process MCP resources
-  for (const [name, endpointMeta] of Object.entries(mcpResourceMeta)) {
-    const functionMeta = functionsMeta[endpointMeta.pikkuFuncName]
-    if (!functionMeta) {
-      logger.warn(
-        `Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping resource ${name}.`
-      )
-      continue
-    }
-
-    const inputType = functionMeta.inputs?.[0]
-    const outputType = functionMeta.outputs?.[0]
-
-    const parameters = await loadSchema(inputType)
-    const returns = await loadSchema(outputType)
-
-    const endpoint = {
-      uri: name,
-      name,
-      description: endpointMeta.description,
-      ...(parameters && { parameters }),
-      ...(returns && { returns }),
-      ...(endpointMeta.streaming && { streaming: true }),
-    }
-
-    resources.push(endpoint)
-  }
-
-  // Process MCP tools
-  for (const [name, endpointMeta] of Object.entries(mcpToolMeta)) {
-    const functionMeta = functionsMeta[endpointMeta.pikkuFuncName]
-    if (!functionMeta) {
-      logger.warn(
-        `Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping tool ${name}.`
-      )
-      continue
-    }
-
-    const inputType = functionMeta.inputs?.[0]
-    const outputType = functionMeta.outputs?.[0]
-
-    const parameters = await loadSchema(inputType)
-    const returns = await loadSchema(outputType)
-
-    const endpoint = {
-      name,
-      description: endpointMeta.description,
-      ...(parameters && { parameters }),
-      ...(returns && { returns }),
-      ...(endpointMeta.streaming && { streaming: true }),
-    }
-
-    tools.push(endpoint)
-  }
-
-  // Process MCP prompts
-  for (const [name, endpointMeta] of Object.entries(mcpPromptMeta)) {
-    const functionMeta = functionsMeta[endpointMeta.pikkuFuncName]
-    if (!functionMeta) {
-      logger.warn(
-        `Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping prompt ${name}.`
-      )
-      continue
-    }
-
-    const inputType = functionMeta.inputs?.[0]
-    // TODO: this needs to be a json schema type, not any
-    const inputSchema: any = await loadSchema(inputType)
-
-    // Generate arguments from input schema
-    const argumentsArray: any[] = []
-    if (
-      inputSchema &&
-      typeof inputSchema === 'object' &&
-      inputSchema.properties
-    ) {
-      const properties = inputSchema.properties as Record<string, any>
-      const required = (inputSchema.required as string[]) || []
-
-      for (const [propName, propSchema] of Object.entries(properties)) {
-        argumentsArray.push({
-          name: propName,
-          description: propSchema.description || `${propName} parameter`,
-          required: required.includes(propName),
-        })
-      }
-    }
-
-    const prompt = {
-      name,
-      description: endpointMeta.description,
-      arguments: argumentsArray,
-    }
-
-    prompts.push(prompt)
-  }
-
-  return JSON.stringify({ tools, resources, prompts }, null, 2)
-}

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

@@ -1,143 +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 } from '${functionTypesImportPath}'
-
-/**
- * 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)
-}
-
-/**
- * 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, 'mcp'>
-    | {
-        func: PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp'>
-        name?: string
-      }
-): PikkuFunctionConfig<In, MCPPromptResponse, 'mcp'> => {
-  return typeof func === 'function' ? { 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, 'mcp'>
-    | {
-      func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp'>
-      name?: string
-    }
-): PikkuFunctionConfig<In, MCPToolResponse, 'mcp'> => {
-  return typeof func === 'function' ? { 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, 'mcp'>
-    | {
-      func: PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp'>
-      name?: string
-    }
-): PikkuFunctionConfig<In, MCPResourceResponse, 'mcp'> => {
-  return typeof func === 'function' ? { func } : func
-}
-`
-}