@pikku/inspector 0.7.6 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @pikku/inspector
 
+## 0.8.0
+
+### Major Features
+
+- **Model Context Protocol (MCP) Analysis**: Added comprehensive MCP endpoint analysis
+- **Queue Worker Analysis**: Added queue analysis
+- **Enhanced Service Analysis**: Added service destructuring analysis for better code generation and type safety
+
+## 0.7.7
+
+### Patch Changes
+
+- 8b4f52e: refactor: moving schemas in channels to functions
+- Updated dependencies [8b4f52e]
+- Updated dependencies [8b4f52e]
+- Updated dependencies [1d70184]
+  - @pikku/core@0.7.8
+
 ## 0.7.6
 
 ### Patch Changes

package/dist/add-channel.js

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
 import { getPropertyValue } from './get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
-import { getInputTypes } from './add-http-route.js';
+import { PikkuEventTypes } from '@pikku/core';
 import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
 /**
  * Safely get the “initializer” expression of a property-like AST node:
@@ -132,8 +132,6 @@ export function addMessagesRoutes(obj, state, checker) {
                                         if (fnMeta) {
                                             result[channelKey][routeKey] = {
                                                 pikkuFuncName: handlerName,
-                                                inputs: fnMeta.inputs ?? null,
-                                                outputs: fnMeta.outputs ?? null,
                                             };
                                             continue;
                                         }
@@ -148,8 +146,6 @@ export function addMessagesRoutes(obj, state, checker) {
                                     if (fnMeta) {
                                         result[channelKey][routeKey] = {
                                             pikkuFuncName: handlerName,
-                                            inputs: fnMeta.inputs ?? null,
-                                            outputs: fnMeta.outputs ?? null,
                                         };
                                         continue;
                                     }
@@ -175,8 +171,6 @@ export function addMessagesRoutes(obj, state, checker) {
                                                 if (fnMeta) {
                                                     result[channelKey][routeKey] = {
                                                         pikkuFuncName: handlerName,
-                                                        inputs: fnMeta.inputs ?? null,
-                                                        outputs: fnMeta.outputs ?? null,
                                                     };
                                                     continue;
                                                 }
@@ -188,8 +182,6 @@ export function addMessagesRoutes(obj, state, checker) {
                                                 if (fnMeta) {
                                                     result[channelKey][routeKey] = {
                                                         pikkuFuncName: handlerName,
-                                                        inputs: fnMeta.inputs ?? null,
-                                                        outputs: fnMeta.outputs ?? null,
                                                     };
                                                     continue;
                                                 }
@@ -215,8 +207,6 @@ export function addMessagesRoutes(obj, state, checker) {
                             }
                             result[channelKey][routeKey] = {
                                 pikkuFuncName: possibleMatch,
-                                inputs: fnMeta.inputs ?? null,
-                                outputs: fnMeta.outputs ?? null,
                             };
                             continue;
                         }
@@ -248,8 +238,6 @@ export function addMessagesRoutes(obj, state, checker) {
                             if (fnMeta) {
                                 result[channelKey][routeKey] = {
                                     pikkuFuncName: handlerName,
-                                    inputs: fnMeta.inputs ?? null,
-                                    outputs: fnMeta.outputs ?? null,
                                 };
                                 continue; // Skip the normal processing below
                             }
@@ -270,8 +258,6 @@ export function addMessagesRoutes(obj, state, checker) {
             }
             result[channelKey][routeKey] = {
                 pikkuFuncName: handlerName,
-                inputs: fnMeta.inputs ?? null,
-                outputs: fnMeta.outputs ?? null,
             };
         }
     }
@@ -306,7 +292,7 @@ export function addChannel(node, checker, state, filters) {
     const docs = getPropertyValue(obj, 'docs');
     const tags = getPropertyValue(obj, 'tags');
     const query = getPropertyValue(obj, 'query');
-    if (!matchesFilters(filters, { tags }, { type: 'channel', name }))
+    if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.channel, name }))
         return;
     const connect = getPropertyAssignmentInitializer(obj, 'onConnect', false, checker);
     const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', false, checker);
@@ -324,8 +310,6 @@ export function addChannel(node, checker, state, filters) {
             message = {
                 pikkuFuncName: extractFunctionName(onMsgProp, checker)
                     .pikkuFuncName,
-                inputs: fnMeta.inputs ?? null,
-                outputs: fnMeta.outputs ?? null,
             };
         }
     }
@@ -339,15 +323,22 @@ export function addChannel(node, checker, state, filters) {
         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, checker).pikkuFuncName
+        disconnect: disconnect
+            ? {
+                pikkuFuncName: extractFunctionName(disconnect, checker)
+                    .pikkuFuncName,
+            }
             : null,
-        disconnect: !!disconnect,
         message,
         messageRoutes,
         docs: docs ?? undefined,

package/dist/add-http-route.js

@@ -1,6 +1,7 @@
 import * as ts from 'typescript';
 import { getPropertyValue } from './get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
+import { PikkuEventTypes } from '@pikku/core';
 import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
 /**
  * Populate metaInputTypes for a given route based on method, input type,
@@ -44,7 +45,7 @@ export const addHTTPRoute = (node, checker, state, filters) => {
     const docs = getPropertyValue(obj, 'docs') || undefined;
     const tags = getPropertyValue(obj, 'tags') || undefined;
     const query = getPropertyValue(obj, 'query') || [];
-    if (!matchesFilters(filters, { tags }, { type: 'http', name: route })) {
+    if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.http, name: route })) {
         return;
     }
     // --- find the referenced function ---

package/dist/add-mcp-prompt.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import { InspectorFilters, InspectorState } from './types.js';
+export declare const addMCPPrompt: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;

package/dist/add-mcp-prompt.js

@@ -0,0 +1,60 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from './get-property-value.js';
+import { PikkuEventTypes } from '@pikku/core';
+import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+export const addMCPPrompt = (node, checker, state, filters) => {
+    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');
+        const descriptionValue = getPropertyValue(obj, 'description');
+        const tags = getPropertyValue(obj, 'tags') || 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/dist/add-mcp-resource.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import { InspectorFilters, InspectorState } from './types.js';
+export declare const addMCPResource: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;

package/dist/add-mcp-resource.js

@@ -0,0 +1,67 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from './get-property-value.js';
+import { PikkuEventTypes } from '@pikku/core';
+import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+export const addMCPResource = (node, checker, state, filters) => {
+    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');
+        const titleValue = getPropertyValue(obj, 'title');
+        const descriptionValue = getPropertyValue(obj, 'description');
+        const streamingValue = getPropertyValue(obj, 'streaming');
+        const tags = getPropertyValue(obj, 'tags') || 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/dist/add-mcp-tool.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import { InspectorFilters, InspectorState } from './types.js';
+export declare const addMCPTool: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;

package/dist/add-mcp-tool.js

@@ -0,0 +1,63 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from './get-property-value.js';
+import { PikkuEventTypes } from '@pikku/core';
+import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+export const addMCPTool = (node, checker, state, filters) => {
+    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');
+        const titleValue = getPropertyValue(obj, 'title');
+        const descriptionValue = getPropertyValue(obj, 'description');
+        const streamingValue = getPropertyValue(obj, 'streaming');
+        const tags = getPropertyValue(obj, 'tags') || 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/dist/add-queue-worker.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import { InspectorFilters, InspectorState } from './types.js';
+export declare const addQueueWorker: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;

package/dist/add-queue-worker.js

@@ -0,0 +1,47 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from './get-property-value.js';
+import { PikkuEventTypes } from '@pikku/core';
+import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+export const addQueueWorker = (node, checker, state, filters) => {
+    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');
+        const docs = getPropertyValue(obj, 'docs') || undefined;
+        const tags = getPropertyValue(obj, 'tags') || 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/dist/add-schedule.js

@@ -1,6 +1,7 @@
 import * as ts from 'typescript';
 import { getPropertyValue } from './get-property-value.js';
-import { extractFunctionName, matchesFilters } from './utils.js';
+import { PikkuEventTypes } from '@pikku/core';
+import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
 export const addSchedule = (node, checker, state, filters) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -21,19 +22,16 @@ export const addSchedule = (node, checker, state, filters) => {
         const scheduleValue = getPropertyValue(obj, 'schedule');
         const docs = getPropertyValue(obj, 'docs') || undefined;
         const tags = getPropertyValue(obj, 'tags') || undefined;
-        // --- find the referenced function ---
-        const funcProp = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
-            ts.isIdentifier(p.name) &&
-            p.name.text === 'func');
-        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, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
         if (!nameValue || !scheduleValue) {
             return;
         }
-        if (!matchesFilters(filters, { tags }, { type: 'schedule', name: nameValue })) {
+        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.scheduled, name: nameValue })) {
             return;
         }
         state.scheduledTasks.files.add(node.getSourceFile().fileName);

package/dist/inspector.js

@@ -29,7 +29,6 @@ export const inspect = (routeFiles, filters) => {
             files: new Set(),
         },
         channels: {
-            metaInputTypes: new Map(),
             files: new Set(),
             meta: {},
         },
@@ -37,9 +36,19 @@ export const inspect = (routeFiles, filters) => {
             meta: {},
             files: new Set(),
         },
+        queueWorkers: {
+            meta: {},
+            files: new Set(),
+        },
         rpc: {
             meta: {},
         },
+        mcpEndpoints: {
+            resourcesMeta: {},
+            toolsMeta: {},
+            promptsMeta: {},
+            files: new Set(),
+        },
     };
     // First sweep: add all functions
     for (const sourceFile of sourceFiles) {

package/dist/types.d.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, {
     variable: string;
     type: string | null;
@@ -28,7 +30,6 @@ export interface InspectorFunctionState {
     meta: FunctionsMeta;
 }
 export interface InspectorChannelState {
-    metaInputTypes: MetaInputTypes;
     meta: ChannelsMeta;
     files: Set<string>;
 }
@@ -49,7 +50,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>;
+    };
 }

package/dist/utils.d.ts

@@ -1,5 +1,6 @@
 import * as ts from 'typescript';
 import { InspectorFilters } from './types.js';
+import { PikkuEventTypes } from '@pikku/core';
 type ExtractedFunctionName = {
     pikkuFuncName: string;
     name: string;
@@ -27,7 +28,7 @@ export declare function getPropertyAssignmentInitializer(obj: ts.ObjectLiteralEx
 export declare const matchesFilters: (filters: InspectorFilters, params: {
     tags?: string[];
 }, meta: {
-    type: "schedule" | "http" | "channel";
+    type: PikkuEventTypes;
     name: string;
 }) => boolean;
 export {};

package/dist/visit.js

@@ -3,6 +3,10 @@ import { addFileWithFactory } from './add-file-with-factory.js';
 import { addFileExtendsCoreType } from './add-file-extends-core-type.js';
 import { addHTTPRoute } from './add-http-route.js';
 import { addSchedule } from './add-schedule.js';
+import { addQueueWorker } from './add-queue-worker.js';
+import { addMCPResource } from './add-mcp-resource.js';
+import { addMCPTool } from './add-mcp-tool.js';
+import { addMCPPrompt } from './add-mcp-prompt.js';
 import { addFunctions } from './add-functions.js';
 import { addChannel } from './add-channel.js';
 export const visitSetup = (checker, node, state, filters) => {
@@ -18,6 +22,10 @@ export const visitSetup = (checker, node, state, filters) => {
 export const visitRoutes = (checker, node, state, filters) => {
     addHTTPRoute(node, checker, state, filters);
     addSchedule(node, checker, state, filters);
+    addQueueWorker(node, checker, state, filters);
     addChannel(node, checker, state, filters);
+    addMCPResource(node, checker, state, filters);
+    addMCPTool(node, checker, state, filters);
+    addMCPPrompt(node, checker, state, filters);
     ts.forEachChild(node, (child) => visitRoutes(checker, child, state, filters));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",
@@ -17,7 +17,7 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@pikku/core": "^0.7.4",
+    "@pikku/core": "^0.8.0",
     "path-to-regexp": "^8.2.0",
     "typescript": "^5.6"
   },