@pikku/inspector 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @pikku/inspector
 
+## 0.8.1
+
+### Patch Changes
+
+- 44e3ff4: feat: enhance CLI filtering with type and directory filters
+
+  - Add --types filter to filter by PikkuEventTypes (http, channel, queue, scheduler, rpc, mcp)
+  - Add --directories filter to filter by file paths/directories
+  - All filters (tags, types, directories) now work together with AND logic
+  - Add comprehensive logging interface to inspector package
+  - Add comprehensive test suite for matchesFilters function
+  - Support cross-platform path handling
+
+- 7c592b8: feat: support for required services and improved service configuration
+
+  This release includes several enhancements to service management and configuration:
+
+  - Added support for required services configuration
+  - Improved service discovery and registration
+  - Added typed RPC clients for service communication
+  - Updated middleware to run per function
+
+- Updated dependencies [3261090]
+- Updated dependencies [7c592b8]
+- Updated dependencies [30a082f]
+  - @pikku/core@0.8.1
+
 ## 0.8.0
 
 ### Major Features

package/dist/add-channel.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import type { ChannelMeta } from '@pikku/core/channel';
-import type { InspectorFilters, InspectorState } from './types.js';
+import type { InspectorFilters, InspectorState, InspectorLogger } from './types.js';
 /**
  * Build out the nested message-routes by looking up each handler
  * in state.functions.meta instead of re-inferring it here.
@@ -10,4 +10,4 @@ export declare function addMessagesRoutes(obj: ts.ObjectLiteralExpression, state
  * Inspect addChannel calls, look up all handlers in state.functions.meta,
  * and emit one entry into state.channels.meta.
  */
-export declare function addChannel(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters): void;
+export declare function addChannel(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger): void;

package/dist/add-channel.js

@@ -267,7 +267,7 @@ export function addMessagesRoutes(obj, state, checker) {
  * Inspect addChannel calls, look up all handlers in state.functions.meta,
  * and emit one entry into state.channels.meta.
  */
-export function addChannel(node, checker, state, filters) {
+export function addChannel(node, checker, state, filters, logger) {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args } = node;
@@ -292,7 +292,8 @@ 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: PikkuEventTypes.channel, name }))
+    const filePath = node.getSourceFile().fileName;
+    if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.channel, name, filePath }, logger))
         return;
     const connect = getPropertyAssignmentInitializer(obj, 'onConnect', false, checker);
     const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', false, checker);

package/dist/add-functions.d.ts

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
-import { InspectorState, InspectorFilters } from './types.js';
+import { InspectorState, InspectorFilters, InspectorLogger } from './types.js';
 /**
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
  */
-export declare function addFunctions(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters): void;
+export declare function addFunctions(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger): void;

package/dist/add-functions.js

@@ -171,7 +171,7 @@ function unwrapPromise(checker, type) {
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
  */
-export function addFunctions(node, checker, state, filters) {
+export function addFunctions(node, checker, state, filters, logger) {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args, typeArguments } = node;
@@ -226,8 +226,7 @@ export function addFunctions(node, checker, state, filters) {
                 }
             }
         }
-        else if (ts.isIdentifier(firstParam.name) &&
-            !firstParam.name.text.startsWith('_')) {
+        else if (ts.isIdentifier(firstParam.name)) {
             services.optimized = false;
         }
     }

package/dist/add-http-route.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { InspectorState, InspectorFilters } from './types.js';
+import { InspectorState, InspectorFilters, InspectorLogger } from './types.js';
 /**
  * Populate metaInputTypes for a given route based on method, input type,
  * query and params. Returns undefined (we only mutate metaTypes).
@@ -13,4 +13,4 @@ export declare const getInputTypes: (metaTypes: Map<string, {
  * Simplified addHTTPRoute: re-uses function metadata from state.functions.meta
  * instead of re-inferring types here.
  */
-export declare const addHTTPRoute: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;
+export declare const addHTTPRoute: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;

package/dist/add-http-route.js

@@ -23,7 +23,7 @@ export const getInputTypes = (metaTypes, methodType, inputType, queryValues, par
  * Simplified addHTTPRoute: re-uses function metadata from state.functions.meta
  * instead of re-inferring types here.
  */
-export const addHTTPRoute = (node, checker, state, filters) => {
+export const addHTTPRoute = (node, checker, state, filters, logger) => {
     // only look at calls
     if (!ts.isCallExpression(node))
         return;
@@ -45,7 +45,8 @@ 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: PikkuEventTypes.http, name: route })) {
+    const filePath = node.getSourceFile().fileName;
+    if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.http, name: route, filePath }, logger)) {
         return;
     }
     // --- find the referenced function ---

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

@@ -1,3 +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;
+import { InspectorFilters, InspectorState, InspectorLogger } from './types.js';
+export declare const addMCPPrompt: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;

package/dist/add-mcp-prompt.js

@@ -2,7 +2,7 @@ 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) => {
+export const addMCPPrompt = (node, checker, state, filters, logger) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -35,7 +35,8 @@ export const addMCPPrompt = (node, checker, state, filters) => {
             console.error(`• MCP prompt '${nameValue}' is missing a description.`);
             return;
         }
-        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.mcp, name: nameValue })) {
+        const filePath = node.getSourceFile().fileName;
+        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.mcp, name: nameValue, filePath }, logger)) {
             return;
         }
         // lookup existing function metadata

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

@@ -1,3 +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;
+import { InspectorFilters, InspectorState, InspectorLogger } from './types.js';
+export declare const addMCPResource: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;

package/dist/add-mcp-resource.js

@@ -2,7 +2,7 @@ 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) => {
+export const addMCPResource = (node, checker, state, filters, logger) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -41,7 +41,8 @@ export const addMCPResource = (node, checker, state, filters) => {
             console.error(`• MCP resource '${uriValue}' is missing a description.`);
             return;
         }
-        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.mcp, name: uriValue })) {
+        const filePath = node.getSourceFile().fileName;
+        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.mcp, name: uriValue, filePath }, logger)) {
             return;
         }
         // lookup existing function metadata

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

@@ -1,3 +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;
+import { InspectorFilters, InspectorState, InspectorLogger } from './types.js';
+export declare const addMCPTool: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;

package/dist/add-mcp-tool.js

@@ -2,7 +2,7 @@ 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) => {
+export const addMCPTool = (node, checker, state, filters, logger) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -37,7 +37,8 @@ export const addMCPTool = (node, checker, state, filters) => {
             console.error(`• MCP tool '${nameValue}' is missing a description.`);
             return;
         }
-        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.mcp, name: nameValue })) {
+        const filePath = node.getSourceFile().fileName;
+        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.mcp, name: nameValue, filePath }, logger)) {
             return;
         }
         // lookup existing function metadata

package/dist/add-queue-worker.d.ts

@@ -1,3 +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;
+import { InspectorFilters, InspectorState, InspectorLogger } from './types.js';
+export declare const addQueueWorker: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;

package/dist/add-queue-worker.js

@@ -2,7 +2,7 @@ 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) => {
+export const addQueueWorker = (node, checker, state, filters, logger) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -32,7 +32,8 @@ export const addQueueWorker = (node, checker, state, filters) => {
             console.error(`• No 'queueName' provided for queue processor function '${pikkuFuncName}'.`);
             return;
         }
-        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.queue, name: queueName })) {
+        const filePath = node.getSourceFile().fileName;
+        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.queue, name: queueName, filePath }, logger)) {
             console.info(`• Skipping queue processor '${pikkuFuncName}' for queue '${queueName}' due to filter mismatch.`);
             return;
         }

package/dist/add-schedule.d.ts

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

package/dist/add-schedule.js

@@ -2,7 +2,7 @@ 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 addSchedule = (node, checker, state, filters) => {
+export const addSchedule = (node, checker, state, filters, logger) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -31,7 +31,8 @@ export const addSchedule = (node, checker, state, filters) => {
         if (!nameValue || !scheduleValue) {
             return;
         }
-        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.scheduled, name: nameValue })) {
+        const filePath = node.getSourceFile().fileName;
+        if (!matchesFilters(filters, { tags }, { type: PikkuEventTypes.scheduler, name: nameValue, filePath }, logger)) {
             return;
         }
         state.scheduledTasks.files.add(node.getSourceFile().fileName);

package/dist/inspector.d.ts

@@ -1,3 +1,3 @@
-import { InspectorState, InspectorHTTPState, InspectorFilters } from './types.js';
+import { InspectorState, InspectorHTTPState, InspectorFilters, InspectorLogger } from './types.js';
 export declare const normalizeHTTPTypes: (httpState: InspectorHTTPState) => InspectorHTTPState;
-export declare const inspect: (routeFiles: string[], filters: InspectorFilters) => InspectorState;
+export declare const inspect: (logger: InspectorLogger, routeFiles: string[], filters: InspectorFilters) => InspectorState;

package/dist/inspector.js

@@ -4,7 +4,7 @@ import { TypesMap } from './types-map.js';
 export const normalizeHTTPTypes = (httpState) => {
     return httpState;
 };
-export const inspect = (routeFiles, filters) => {
+export const inspect = (logger, routeFiles, filters) => {
     const program = ts.createProgram(routeFiles, {
         target: ts.ScriptTarget.ESNext,
         module: ts.ModuleKind.CommonJS,
@@ -52,11 +52,11 @@ export const inspect = (routeFiles, filters) => {
     };
     // First sweep: add all functions
     for (const sourceFile of sourceFiles) {
-        ts.forEachChild(sourceFile, (child) => visitSetup(checker, child, state, filters));
+        ts.forEachChild(sourceFile, (child) => visitSetup(checker, child, state, filters, logger));
     }
     // Second sweep: add all transports
     for (const sourceFile of sourceFiles) {
-        ts.forEachChild(sourceFile, (child) => visitRoutes(checker, child, state, filters));
+        ts.forEachChild(sourceFile, (child) => visitRoutes(checker, child, state, filters, logger));
     }
     // Normalise the typesMap
     state.http = normalizeHTTPTypes(state.http);

package/dist/types.d.ts

@@ -35,7 +35,15 @@ export interface InspectorChannelState {
 }
 export type InspectorFilters = {
     tags?: string[];
+    types?: string[];
+    directories?: string[];
 };
+export interface InspectorLogger {
+    info: (message: string) => void;
+    error: (message: string) => void;
+    warn: (message: string) => void;
+    debug: (message: string) => void;
+}
 export interface InspectorState {
     singletonServicesTypeImportMap: PathToNameAndType;
     sessionServicesTypeImportMap: PathToNameAndType;

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { InspectorFilters } from './types.js';
+import { InspectorFilters, InspectorLogger } from './types.js';
 import { PikkuEventTypes } from '@pikku/core';
 type ExtractedFunctionName = {
     pikkuFuncName: string;
@@ -30,5 +30,6 @@ export declare const matchesFilters: (filters: InspectorFilters, params: {
 }, meta: {
     type: PikkuEventTypes;
     name: string;
-}) => boolean;
+    filePath?: string;
+}, logger: InspectorLogger) => boolean;
 export {};

package/dist/utils.js

@@ -660,13 +660,48 @@ export function getPropertyAssignmentInitializer(obj, propName, followShorthand
     }
     return undefined;
 }
-export const matchesFilters = (filters, params, meta) => {
-    if (Object.keys(filters).length === 0 || filters.tags?.length === 0) {
+export const matchesFilters = (filters, params, meta, logger) => {
+    // If no filters are provided, allow everything
+    if (Object.keys(filters).length === 0) {
         return true;
     }
-    if (filters.tags?.some((tag) => params.tags?.includes(tag))) {
+    // If all filter arrays are empty, allow everything
+    if ((!filters.tags || filters.tags.length === 0) &&
+        (!filters.types || filters.types.length === 0) &&
+        (!filters.directories || filters.directories.length === 0)) {
         return true;
     }
-    console.debug(`⒡ Filtered: ${meta.type}:${meta.name}`);
-    return false;
+    // Check type filter
+    if (filters.types && filters.types.length > 0) {
+        if (!filters.types.includes(meta.type)) {
+            logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check directory filter
+    if (filters.directories && filters.directories.length > 0) {
+        if (!meta.filePath) {
+            logger.debug(`⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`);
+            return false;
+        }
+        const matchesDirectory = filters.directories.some((dir) => {
+            // Normalize paths for comparison
+            const normalizedFilePath = meta.filePath.replace(/\\/g, '/');
+            const normalizedDir = dir.replace(/\\/g, '/');
+            return normalizedFilePath.includes(normalizedDir);
+        });
+        if (!matchesDirectory) {
+            logger.debug(`⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`);
+            return false;
+        }
+    }
+    // Check tag filter
+    if (filters.tags && filters.tags.length > 0) {
+        if (!params.tags ||
+            !filters.tags.some((tag) => params.tags.includes(tag))) {
+            logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    return true;
 };

package/dist/visit.d.ts

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

package/dist/visit.js

@@ -9,23 +9,23 @@ 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) => {
+export const visitSetup = (checker, node, state, filters, logger) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices');
     addFileExtendsCoreType(node, checker, state.sessionServicesTypeImportMap, 'CoreServices');
     addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession');
     addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices');
     addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices');
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
-    addFunctions(node, checker, state, filters);
-    ts.forEachChild(node, (child) => visitSetup(checker, child, state, filters));
+    addFunctions(node, checker, state, filters, logger);
+    ts.forEachChild(node, (child) => visitSetup(checker, child, state, filters, logger));
 };
-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));
+export const visitRoutes = (checker, node, state, filters, logger) => {
+    addHTTPRoute(node, checker, state, filters, logger);
+    addSchedule(node, checker, state, filters, logger);
+    addQueueWorker(node, checker, state, filters, logger);
+    addChannel(node, checker, state, filters, logger);
+    addMCPResource(node, checker, state, filters, logger);
+    addMCPTool(node, checker, state, filters, logger);
+    addMCPPrompt(node, checker, state, filters, logger);
+    ts.forEachChild(node, (child) => visitRoutes(checker, child, state, filters, logger));
 };