@pikku/inspector 0.7.6 → 0.8.0

package/src/add-channel.ts

@@ -1,8 +1,7 @@
 import * as ts from 'typescript'
 import { getPropertyValue } from './get-property-value.js'
 import { pathToRegexp } from 'path-to-regexp'
-import { APIDocs } from '@pikku/core'
-import { getInputTypes } from './add-http-route.js'
+import { APIDocs, PikkuEventTypes } from '@pikku/core'
 import {
   extractFunctionName,
   getPropertyAssignmentInitializer,
@@ -189,8 +188,6 @@ export function addMessagesRoutes(
                     if (fnMeta) {
                       result[channelKey]![routeKey] = {
                         pikkuFuncName: handlerName,
-                        inputs: fnMeta.inputs ?? null,
-                        outputs: fnMeta.outputs ?? null,
                       }
                       continue
                     }
@@ -208,8 +205,6 @@ export function addMessagesRoutes(
                   if (fnMeta) {
                     result[channelKey]![routeKey] = {
                       pikkuFuncName: handlerName,
-                      inputs: fnMeta.inputs ?? null,
-                      outputs: fnMeta.outputs ?? null,
                     }
                     continue
                   }
@@ -244,8 +239,6 @@ export function addMessagesRoutes(
                         if (fnMeta) {
                           result[channelKey]![routeKey] = {
                             pikkuFuncName: handlerName,
-                            inputs: fnMeta.inputs ?? null,
-                            outputs: fnMeta.outputs ?? null,
                           }
                           continue
                         }
@@ -260,8 +253,6 @@ export function addMessagesRoutes(
                         if (fnMeta) {
                           result[channelKey]![routeKey] = {
                             pikkuFuncName: handlerName,
-                            inputs: fnMeta.inputs ?? null,
-                            outputs: fnMeta.outputs ?? null,
                           }
                           continue
                         }
@@ -294,8 +285,6 @@ export function addMessagesRoutes(
               }
               result[channelKey]![routeKey] = {
                 pikkuFuncName: possibleMatch,
-                inputs: fnMeta.inputs ?? null,
-                outputs: fnMeta.outputs ?? null,
               }
               continue
             }
@@ -334,8 +323,6 @@ export function addMessagesRoutes(
               if (fnMeta) {
                 result[channelKey]![routeKey] = {
                   pikkuFuncName: handlerName,
-                  inputs: fnMeta.inputs ?? null,
-                  outputs: fnMeta.outputs ?? null,
                 }
                 continue // Skip the normal processing below
               }
@@ -361,8 +348,6 @@ export function addMessagesRoutes(
 
       result[channelKey]![routeKey] = {
         pikkuFuncName: handlerName,
-        inputs: fnMeta.inputs ?? null,
-        outputs: fnMeta.outputs ?? null,
       }
     }
   }
@@ -406,7 +391,10 @@ export function addChannel(
   const tags = getPropertyValue(obj, 'tags') as string[] | undefined
   const query = getPropertyValue(obj, 'query') as string[] | []
 
-  if (!matchesFilters(filters, { tags }, { type: 'channel', name })) return
+  if (
+    !matchesFilters(filters, { tags }, { type: PikkuEventTypes.channel, name })
+  )
+    return
 
   const connect = getPropertyAssignmentInitializer(
     obj,
@@ -429,6 +417,7 @@ export function addChannel(
     false,
     checker
   )
+
   if (onMsgProp) {
     const handlerName =
       onMsgProp && getHandlerNameFromExpression(onMsgProp, checker)
@@ -442,8 +431,6 @@ export function addChannel(
       message = {
         pikkuFuncName: extractFunctionName(onMsgProp as any, checker)
           .pikkuFuncName,
-        inputs: fnMeta.inputs ?? null,
-        outputs: fnMeta.outputs ?? null,
       }
     }
   }
@@ -459,21 +446,22 @@ export function addChannel(
     input: null,
     params: params.length ? params : undefined,
     query: query?.length ? query : undefined,
-    inputTypes: getInputTypes(
-      state.channels.metaInputTypes,
-      'get',
-      message?.inputs?.[0] ?? null,
-      query,
-      params
-    ),
-    connectPikkuFuncName: connect
-      ? extractFunctionName(connect, checker).pikkuFuncName
+    // inputTypes: getInputTypes(
+    //   state.channels.metaInputTypes,
+    //   'get',
+    //   null, // TODO
+    //   query,
+    //   params
+    // ),
+    connect: connect
+      ? { pikkuFuncName: extractFunctionName(connect, checker).pikkuFuncName }
       : null,
-    connect: !!connect,
-    disconnectPikkuFuncName: disconnect
-      ? extractFunctionName(disconnect as any, checker).pikkuFuncName
+    disconnect: disconnect
+      ? {
+          pikkuFuncName: extractFunctionName(disconnect as any, checker)
+            .pikkuFuncName,
+        }
       : null,
-    disconnect: !!disconnect,
     message,
     messageRoutes,
     docs: docs ?? undefined,

package/src/add-http-route.ts

@@ -2,7 +2,7 @@ import * as ts from 'typescript'
 import { getPropertyValue } from './get-property-value.js'
 import { pathToRegexp } from 'path-to-regexp'
 import { HTTPMethod } from '@pikku/core/http'
-import { APIDocs } from '@pikku/core'
+import { APIDocs, PikkuEventTypes } from '@pikku/core'
 import {
   extractFunctionName,
   getPropertyAssignmentInitializer,
@@ -69,7 +69,13 @@ export const addHTTPRoute = (
   const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
   const query = (getPropertyValue(obj, 'query') as string[]) || []
 
-  if (!matchesFilters(filters, { tags }, { type: 'http', name: route })) {
+  if (
+    !matchesFilters(
+      filters,
+      { tags },
+      { type: PikkuEventTypes.http, name: route }
+    )
+  ) {
     return
   }
 

package/src/add-mcp-prompt.ts

@@ -0,0 +1,100 @@
+import * as ts from 'typescript'
+import { getPropertyValue } from './get-property-value.js'
+import { PikkuEventTypes } from '@pikku/core'
+import { InspectorFilters, InspectorState } from './types.js'
+import {
+  extractFunctionName,
+  getPropertyAssignmentInitializer,
+  matchesFilters,
+} from './utils.js'
+
+export const addMCPPrompt = (
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  state: InspectorState,
+  filters: InspectorFilters
+) => {
+  if (!ts.isCallExpression(node)) {
+    return
+  }
+
+  const args = node.arguments
+  const firstArg = args[0]
+  const expression = node.expression
+
+  // Check if the call is to addMCPPrompt
+  if (!ts.isIdentifier(expression) || expression.text !== 'addMCPPrompt') {
+    return
+  }
+
+  if (!firstArg) {
+    return
+  }
+
+  if (ts.isObjectLiteralExpression(firstArg)) {
+    const obj = firstArg
+
+    const nameValue = getPropertyValue(obj, 'name') as string | null
+    const descriptionValue = getPropertyValue(obj, 'description') as
+      | string
+      | null
+    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+
+    const funcInitializer = getPropertyAssignmentInitializer(
+      obj,
+      'func',
+      true,
+      checker
+    )
+    if (!funcInitializer) {
+      console.error(`• No valid 'func' property for MCP prompt '${nameValue}'.`)
+      return
+    }
+
+    const pikkuFuncName = extractFunctionName(
+      funcInitializer,
+      checker
+    ).pikkuFuncName
+
+    if (!nameValue) {
+      console.error(`• MCP prompt is missing the required 'name' property.`)
+      return
+    }
+
+    if (!descriptionValue) {
+      console.error(`• MCP prompt '${nameValue}' is missing a description.`)
+      return
+    }
+
+    if (
+      !matchesFilters(
+        filters,
+        { tags },
+        { type: PikkuEventTypes.mcp, name: nameValue }
+      )
+    ) {
+      return
+    }
+
+    // lookup existing function metadata
+    const fnMeta = state.functions.meta[pikkuFuncName]
+    if (!fnMeta) {
+      console.error(`• No function metadata found for '${pikkuFuncName}'.`)
+      return
+    }
+    const inputSchema = fnMeta.inputs?.[0] || null
+    const outputSchema = fnMeta.outputs?.[0] || null
+
+    state.mcpEndpoints.files.add(node.getSourceFile().fileName)
+
+    state.mcpEndpoints.promptsMeta[nameValue] = {
+      pikkuFuncName,
+      name: nameValue,
+      description: descriptionValue,
+      tags,
+      inputSchema,
+      outputSchema,
+      arguments: [], // Will be populated by CLI during serialization
+    }
+  }
+}

package/src/add-mcp-resource.ts

@@ -0,0 +1,112 @@
+import * as ts from 'typescript'
+import { getPropertyValue } from './get-property-value.js'
+import { PikkuEventTypes } from '@pikku/core'
+import { InspectorFilters, InspectorState } from './types.js'
+import {
+  extractFunctionName,
+  getPropertyAssignmentInitializer,
+  matchesFilters,
+} from './utils.js'
+
+export const addMCPResource = (
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  state: InspectorState,
+  filters: InspectorFilters
+) => {
+  if (!ts.isCallExpression(node)) {
+    return
+  }
+
+  const args = node.arguments
+  const firstArg = args[0]
+  const expression = node.expression
+
+  // Check if the call is to addMCPResource
+  if (!ts.isIdentifier(expression) || expression.text !== 'addMCPResource') {
+    return
+  }
+
+  if (!firstArg) {
+    return
+  }
+
+  if (ts.isObjectLiteralExpression(firstArg)) {
+    const obj = firstArg
+
+    const uriValue = getPropertyValue(obj, 'uri') as string | null
+    const titleValue = getPropertyValue(obj, 'title') as string | null
+    const descriptionValue = getPropertyValue(obj, 'description') as
+      | string
+      | null
+    const streamingValue = getPropertyValue(obj, 'streaming') as boolean | null
+    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+
+    const funcInitializer = getPropertyAssignmentInitializer(
+      obj,
+      'func',
+      true,
+      checker
+    )
+    if (!funcInitializer) {
+      console.error(
+        `• No valid 'func' property for MCP resource '${uriValue}'.`
+      )
+      return
+    }
+
+    const pikkuFuncName = extractFunctionName(
+      funcInitializer,
+      checker
+    ).pikkuFuncName
+
+    if (!uriValue) {
+      console.error(`• MCP resource is missing the required 'uri' property.`)
+      return
+    }
+
+    if (!titleValue) {
+      console.error(
+        `• MCP resource '${uriValue}' is missing the required 'title' property.`
+      )
+      return
+    }
+
+    if (!descriptionValue) {
+      console.error(`• MCP resource '${uriValue}' is missing a description.`)
+      return
+    }
+
+    if (
+      !matchesFilters(
+        filters,
+        { tags },
+        { type: PikkuEventTypes.mcp, name: uriValue }
+      )
+    ) {
+      return
+    }
+
+    // lookup existing function metadata
+    const fnMeta = state.functions.meta[pikkuFuncName]
+    if (!fnMeta) {
+      console.error(`• No function metadata found for '${pikkuFuncName}'.`)
+      return
+    }
+    const inputSchema = fnMeta.inputs?.[0] || null
+    const outputSchema = fnMeta.outputs?.[0] || null
+
+    state.mcpEndpoints.files.add(node.getSourceFile().fileName)
+
+    state.mcpEndpoints.resourcesMeta[uriValue] = {
+      pikkuFuncName,
+      uri: uriValue,
+      title: titleValue,
+      description: descriptionValue,
+      ...(streamingValue !== null && { streaming: streamingValue }),
+      tags,
+      inputSchema,
+      outputSchema,
+    }
+  }
+}

package/src/add-mcp-tool.ts

@@ -0,0 +1,103 @@
+import * as ts from 'typescript'
+import { getPropertyValue } from './get-property-value.js'
+import { PikkuEventTypes } from '@pikku/core'
+import { InspectorFilters, InspectorState } from './types.js'
+import {
+  extractFunctionName,
+  getPropertyAssignmentInitializer,
+  matchesFilters,
+} from './utils.js'
+
+export const addMCPTool = (
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  state: InspectorState,
+  filters: InspectorFilters
+) => {
+  if (!ts.isCallExpression(node)) {
+    return
+  }
+
+  const args = node.arguments
+  const firstArg = args[0]
+  const expression = node.expression
+
+  // Check if the call is to addMCPTool
+  if (!ts.isIdentifier(expression) || expression.text !== 'addMCPTool') {
+    return
+  }
+
+  if (!firstArg) {
+    return
+  }
+
+  if (ts.isObjectLiteralExpression(firstArg)) {
+    const obj = firstArg
+
+    const nameValue = getPropertyValue(obj, 'name') as string | null
+    const titleValue = getPropertyValue(obj, 'title') as string | null
+    const descriptionValue = getPropertyValue(obj, 'description') as
+      | string
+      | null
+    const streamingValue = getPropertyValue(obj, 'streaming') as boolean | null
+    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+
+    const funcInitializer = getPropertyAssignmentInitializer(
+      obj,
+      'func',
+      true,
+      checker
+    )
+    if (!funcInitializer) {
+      console.error(`• No valid 'func' property for MCP tool '${nameValue}'.`)
+      return
+    }
+
+    const pikkuFuncName = extractFunctionName(
+      funcInitializer,
+      checker
+    ).pikkuFuncName
+
+    if (!nameValue) {
+      console.error(`• MCP tool is missing the required 'name' property.`)
+      return
+    }
+
+    if (!descriptionValue) {
+      console.error(`• MCP tool '${nameValue}' is missing a description.`)
+      return
+    }
+
+    if (
+      !matchesFilters(
+        filters,
+        { tags },
+        { type: PikkuEventTypes.mcp, name: nameValue }
+      )
+    ) {
+      return
+    }
+
+    // lookup existing function metadata
+    const fnMeta = state.functions.meta[pikkuFuncName]
+    if (!fnMeta) {
+      console.error(`• No function metadata found for '${pikkuFuncName}'.`)
+      return
+    }
+    const inputSchema = fnMeta.inputs?.[0] || null
+    const outputSchema = fnMeta.outputs?.[0] || null
+
+    state.mcpEndpoints.files.add(node.getSourceFile().fileName)
+
+    state.mcpEndpoints.toolsMeta[nameValue] = {
+      pikkuFuncName,
+      name: nameValue,
+      title: titleValue || undefined,
+      description: descriptionValue,
+      ...(streamingValue !== null && { streaming: streamingValue }),
+      tags,
+      inputSchema,
+      outputSchema,
+    }
+  }
+}

package/src/add-queue-worker.ts

@@ -0,0 +1,88 @@
+import * as ts from 'typescript'
+import { getPropertyValue } from './get-property-value.js'
+import { APIDocs, PikkuEventTypes } from '@pikku/core'
+import { InspectorFilters, InspectorState } from './types.js'
+import {
+  extractFunctionName,
+  getPropertyAssignmentInitializer,
+  matchesFilters,
+} from './utils.js'
+
+export const addQueueWorker = (
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  state: InspectorState,
+  filters: InspectorFilters
+) => {
+  if (!ts.isCallExpression(node)) {
+    return
+  }
+
+  const args = node.arguments
+  const firstArg = args[0]
+  const expression = node.expression
+
+  // Check if the call is to addQueueWorker
+  if (!ts.isIdentifier(expression) || expression.text !== 'addQueueWorker') {
+    return
+  }
+
+  if (!firstArg) {
+    return
+  }
+
+  if (ts.isObjectLiteralExpression(firstArg)) {
+    const obj = firstArg
+
+    const queueName = getPropertyValue(obj, 'queueName') as string | null
+    const docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
+    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+
+    // --- find the referenced function ---
+    const funcInitializer = getPropertyAssignmentInitializer(
+      obj,
+      'func',
+      true,
+      checker
+    )
+    if (!funcInitializer) {
+      console.error(
+        `• No valid 'func' property for queue processor '${queueName}'.`
+      )
+      return
+    }
+
+    const pikkuFuncName = extractFunctionName(
+      funcInitializer,
+      checker
+    ).pikkuFuncName
+
+    if (!queueName) {
+      console.error(
+        `• No 'queueName' provided for queue processor function '${pikkuFuncName}'.`
+      )
+      return
+    }
+
+    if (
+      !matchesFilters(
+        filters,
+        { tags },
+        { type: PikkuEventTypes.queue, name: queueName }
+      )
+    ) {
+      console.info(
+        `• Skipping queue processor '${pikkuFuncName}' for queue '${queueName}' due to filter mismatch.`
+      )
+      return
+    }
+
+    state.queueWorkers.files.add(node.getSourceFile().fileName)
+    state.queueWorkers.meta[queueName] = {
+      pikkuFuncName,
+      queueName,
+      docs,
+      tags,
+    }
+  }
+}

package/src/add-schedule.ts

@@ -1,8 +1,12 @@
 import * as ts from 'typescript'
 import { getPropertyValue } from './get-property-value.js'
-import { APIDocs } from '@pikku/core'
+import { APIDocs, PikkuEventTypes } from '@pikku/core'
 import { InspectorFilters, InspectorState } from './types.js'
-import { extractFunctionName, matchesFilters } from './utils.js'
+import {
+  extractFunctionName,
+  getPropertyAssignmentInitializer,
+  matchesFilters,
+} from './utils.js'
 
 export const addSchedule = (
   node: ts.Node,
@@ -35,22 +39,21 @@ export const addSchedule = (
     const docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
     const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
 
-    // --- find the referenced function ---
-    const funcProp = obj.properties.find(
-      (p) =>
-        ts.isPropertyAssignment(p) &&
-        ts.isIdentifier(p.name) &&
-        p.name.text === 'func'
-    ) as ts.PropertyAssignment | undefined
-
-    if (!funcProp || !ts.isIdentifier(funcProp.initializer)) {
+    const funcInitializer = getPropertyAssignmentInitializer(
+      obj,
+      'func',
+      true,
+      checker
+    )
+    if (!funcInitializer) {
       console.error(
         `• No valid 'func' property for scheduled task '${nameValue}'.`
       )
       return
     }
+
     const pikkuFuncName = extractFunctionName(
-      funcProp.initializer,
+      funcInitializer,
       checker
     ).pikkuFuncName
 
@@ -59,7 +62,11 @@ export const addSchedule = (
     }
 
     if (
-      !matchesFilters(filters, { tags }, { type: 'schedule', name: nameValue })
+      !matchesFilters(
+        filters,
+        { tags },
+        { type: PikkuEventTypes.scheduled, name: nameValue }
+      )
     ) {
       return
     }

package/src/inspector.ts

@@ -42,7 +42,6 @@ export const inspect = (
       files: new Set(),
     },
     channels: {
-      metaInputTypes: new Map(),
       files: new Set(),
       meta: {},
     },
@@ -50,9 +49,19 @@ export const inspect = (
       meta: {},
       files: new Set(),
     },
+    queueWorkers: {
+      meta: {},
+      files: new Set(),
+    },
     rpc: {
       meta: {},
     },
+    mcpEndpoints: {
+      resourcesMeta: {},
+      toolsMeta: {},
+      promptsMeta: {},
+      files: new Set(),
+    },
   }
 
   // First sweep: add all functions

package/src/types.ts

@@ -1,9 +1,11 @@
 import { ChannelsMeta } from '@pikku/core/channel'
 import { HTTPRoutesMeta } from '@pikku/core/http'
 import { ScheduledTasksMeta } from '@pikku/core/scheduler'
+import { queueWorkersMeta } from '@pikku/core/queue'
+import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core'
 import { TypesMap } from './types-map.js'
 import { FunctionsMeta } from '@pikku/core'
-import { RPCMeta } from '../../core/src/rpc/rpc-types.js'
+import { RPCMeta } from '@pikku/core/rpc'
 
 export type PathToNameAndType = Map<
   string,
@@ -32,7 +34,6 @@ export interface InspectorFunctionState {
 }
 
 export interface InspectorChannelState {
-  metaInputTypes: MetaInputTypes
   meta: ChannelsMeta
   files: Set<string>
 }
@@ -54,7 +55,17 @@ export interface InspectorState {
     meta: ScheduledTasksMeta
     files: Set<string>
   }
+  queueWorkers: {
+    meta: queueWorkersMeta
+    files: Set<string>
+  }
   rpc: {
     meta: Record<string, RPCMeta>
   }
+  mcpEndpoints: {
+    resourcesMeta: MCPResourceMeta
+    toolsMeta: MCPToolMeta
+    promptsMeta: MCPPromptMeta
+    files: Set<string>
+  }
 }