@pikku/cli 0.7.7 → 0.8.1

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

@@ -0,0 +1,54 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { generateSchemas } from '../../schema-generator.js'
+import { generateOpenAPISpec } from './openapi-spec-generator.js'
+import { stringify } from 'yaml'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuOpenAPI: PikkuCommand = async (
+  logger,
+  { tsconfig, openAPI },
+  { http, functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating OpenAPI spec',
+    'Created OpenAPI spec',
+    [openAPI?.outputFile === undefined, 'openAPI outfile is not defined'],
+    async () => {
+      if (!openAPI?.outputFile) {
+        throw new Error('openAPI is required')
+      }
+      const schemas = await generateSchemas(
+        logger,
+        tsconfig,
+        functions.typesMap,
+        functions.meta,
+        http.meta
+      )
+      const openAPISpec = await generateOpenAPISpec(
+        functions.meta,
+        http.meta,
+        schemas,
+        openAPI.additionalInfo
+      )
+      if (openAPI.outputFile.endsWith('.json')) {
+        await writeFileInDir(
+          logger,
+          openAPI.outputFile,
+          JSON.stringify(openAPISpec, null, 2),
+          { ignoreModifyComment: true }
+        )
+      } else if (
+        openAPI.outputFile.endsWith('.yaml') ||
+        openAPI.outputFile.endsWith('.yml')
+      ) {
+        await writeFileInDir(
+          logger,
+          openAPI.outputFile,
+          stringify(openAPISpec),
+          { ignoreModifyComment: true }
+        )
+      }
+    }
+  )
+}

package/{bin → src/events/http}/pikku-http-routes.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 pikkuHTTP = async (
+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],
@@ -18,6 +21,7 @@ export const pikkuHTTP = async (
       const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig
       const { http } = visitState
       await writeFileInDir(
+        logger,
         httpRoutesFile,
         serializeFileImports(
           'addHTTPRoute',
@@ -27,6 +31,7 @@ export const pikkuHTTP = async (
         )
       )
       await writeFileInDir(
+        logger,
         httpRoutesMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
       )

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

@@ -1,7 +1,8 @@
 import { HTTPRoutesMeta } from '@pikku/core/http'
-import { serializeImportMap } from './utils/serialize-import-map.js'
+import { serializeImportMap } from '../../serialize-import-map.js'
 import { MetaInputTypes, TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
+import { generateCustomTypes } from '../../utils.js'
 
 export const serializeTypedRoutesMap = (
   relativeToPath: string,
@@ -54,24 +55,6 @@ export type RoutesWithMethod<Method extends string> = {
   `
 }
 
-export function generateCustomTypes(
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-${Array.from(typesMap.customTypes.entries())
-  .map(([name, { type, references }]) => {
-    references.forEach((name) => {
-      const originalName = typesMap.getTypeMeta(name).originalName
-      requiredTypes.add(originalName)
-    })
-    return `export type ${name} = ${type}`
-  })
-  .join('\n')}`
-}
-
 function generateRoutes(
   routesMeta: HTTPRoutesMeta,
   functionsMeta: FunctionsMeta,

package/src/events/mcp/pikku-command-mcp-json.ts

@@ -0,0 +1,33 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { serializeMCPJson } from './serialize-mcp-json.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuMCPJSON: PikkuCommand = async (
+  logger,
+  { mcpJsonFile, schemaDirectory },
+  { mcpEndpoints, functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Generating MCP JSON',
+    'Generated MCP JSON',
+    [mcpEndpoints.files.size === 0 || !mcpJsonFile],
+    async () => {
+      // 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,
+        })
+      }
+    }
+  )
+}

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

@@ -0,0 +1,110 @@
+import {
+  logCommandInfoAndTime,
+  serializeFileImports,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+import { readFile } from 'fs/promises'
+import { join } from 'path'
+
+// 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: PikkuCommand = async (
+  logger,
+  { mcpEndpointsFile, mcpEndpointsMetaFile, packageMappings, schemaDirectory },
+  { mcpEndpoints, functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Finding MCP endpoints',
+    'Found MCP endpoints',
+    [mcpEndpoints.files.size === 0],
+    async () => {
+      await writeFileInDir(
+        logger,
+        mcpEndpointsFile,
+        serializeFileImports(
+          'addMCPResource or addMCPTool',
+          mcpEndpointsFile,
+          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
+          )
+        }
+      }
+
+      await writeFileInDir(
+        logger,
+        mcpEndpointsMetaFile,
+        `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)})`
+      )
+    }
+  )
+}

package/src/events/mcp/serialize-mcp-json.ts

@@ -0,0 +1,159 @@
+import { readFile } from 'fs/promises'
+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'
+
+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/events/queue/pikku-command-queue-map.ts

@@ -0,0 +1,26 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { serializeQueueMap } from './serialize-queue-map.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuQueueMap: PikkuCommand = async (
+  logger,
+  { queueMapDeclarationFile, packageMappings },
+  { queueWorkers, functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating Queue map',
+    'Created Queue map',
+    [queueWorkers.files.size === 0],
+    async () => {
+      const content = serializeQueueMap(
+        queueMapDeclarationFile,
+        packageMappings,
+        functions.typesMap,
+        functions.meta,
+        queueWorkers.meta
+      )
+      await writeFileInDir(logger, queueMapDeclarationFile, content)
+    }
+  )
+}

package/src/events/queue/pikku-command-queue-service.ts

@@ -0,0 +1,33 @@
+import { serializeQueueWrapper } from './serialize-queue-wrapper.js'
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommandWithoutState } from '../../types.js'
+
+export const pikkuQueueService: PikkuCommandWithoutState = async (
+  logger,
+  { queueFile, queueMapDeclarationFile, packageMappings }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Generating queue service wrapper',
+    'Generated queue service wrapper',
+    [queueFile === undefined, "queueFile isn't set in the pikku config"],
+    async () => {
+      if (!queueFile) {
+        throw new Error("queueFile is isn't set in the pikku config")
+      }
+
+      const queueMapDeclarationPath = getFileImportRelativePath(
+        queueFile,
+        queueMapDeclarationFile,
+        packageMappings
+      )
+
+      const content = [serializeQueueWrapper(queueMapDeclarationPath)]
+      await writeFileInDir(logger, queueFile, content.join('\n'))
+    }
+  )
+}

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

@@ -0,0 +1,42 @@
+import { PikkuCLIConfig } from '../../pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import {
+  logCommandInfoAndTime,
+  serializeFileImports,
+  writeFileInDir,
+} from '../../utils.js'
+import { serializeQueueMeta } from './serialize-queue-meta.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuQueue: PikkuCommand = async (
+  logger,
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Finding queues',
+    'Found queue',
+    [visitState.queueWorkers.files.size === 0],
+    async () => {
+      const { queueWorkersFile, queueWorkersMetaFile, packageMappings } =
+        cliConfig
+      const { queueWorkers } = visitState
+      await writeFileInDir(
+        logger,
+        queueWorkersMetaFile,
+        serializeQueueMeta(queueWorkers.meta)
+      )
+      await writeFileInDir(
+        logger,
+        queueWorkersFile,
+        serializeFileImports(
+          'addQueueWorkers',
+          queueWorkersFile,
+          queueWorkers.files,
+          packageMappings
+        )
+      )
+    }
+  )
+}

package/src/events/queue/pikku-queue-map.ts

@@ -0,0 +1,26 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { serializeQueueMap } from './serialize-queue-map.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuQueueMap: PikkuCommand = async (
+  logger,
+  { queueMapDeclarationFile, packageMappings },
+  { queueWorkers, functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating Queue map',
+    'Created Queue map',
+    [queueWorkers.files.size === 0],
+    async () => {
+      const content = serializeQueueMap(
+        queueMapDeclarationFile,
+        packageMappings,
+        functions.typesMap,
+        functions.meta,
+        queueWorkers.meta
+      )
+      await writeFileInDir(logger, queueMapDeclarationFile, content)
+    }
+  )
+}

package/src/events/queue/pikku-queue.ts

@@ -0,0 +1,40 @@
+import {
+  logCommandInfoAndTime,
+  serializeFileImports,
+  writeFileInDir,
+} from '../../utils.js'
+import { serializeQueueMeta } from './serialize-queue-meta.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuQueue: PikkuCommand = async (
+  logger,
+  cliConfig,
+  visitState
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Finding queues',
+    'Found queue',
+    [visitState.queueWorkers.files.size === 0],
+    async () => {
+      const { queueWorkersFile, queueWorkersMetaFile, packageMappings } =
+        cliConfig
+      const { queueWorkers } = visitState
+      await writeFileInDir(
+        logger,
+        queueWorkersMetaFile,
+        serializeQueueMeta(queueWorkers.meta)
+      )
+      await writeFileInDir(
+        logger,
+        queueWorkersFile,
+        serializeFileImports(
+          'addQueueWorkers',
+          queueWorkersFile,
+          queueWorkers.files,
+          packageMappings
+        )
+      )
+    }
+  )
+}