@pikku/inspector 0.7.7 → 0.8.1

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,
@@ -38,6 +40,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
@@ -53,7 +64,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/src/utils.test.ts

@@ -0,0 +1,484 @@
+import { test, describe } from 'node:test'
+import { strict as assert } from 'node:assert'
+import { matchesFilters } from './utils.js'
+import { InspectorFilters } from './types.js'
+import { PikkuEventTypes } from '@pikku/core'
+
+describe('matchesFilters', () => {
+  // Mock logger for testing
+  const mockLogger = {
+    info: () => {},
+    error: () => {},
+    warn: () => {},
+    debug: () => {},
+  }
+
+  describe('Empty filters', () => {
+    test('should return true when no filters are provided', () => {
+      const filters: InspectorFilters = {}
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return true when all filter arrays are empty', () => {
+      const filters: InspectorFilters = {
+        tags: [],
+        types: [],
+        directories: [],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+  })
+
+  describe('Tag filtering', () => {
+    test('should return true when tags match', () => {
+      const filters: InspectorFilters = {
+        tags: ['api', 'public'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'internal'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when tags do not match', () => {
+      const filters: InspectorFilters = {
+        tags: ['api', 'public'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['internal', 'private'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should return false when function has no tags but filter requires tags', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: undefined },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should return false when function has empty tags but filter requires tags', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: [] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('Type filtering', () => {
+    test('should return true when type matches', () => {
+      const filters: InspectorFilters = {
+        types: ['http', 'channel'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when type does not match', () => {
+      const filters: InspectorFilters = {
+        types: ['channel', 'queue'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle all PikkuEventTypes correctly', () => {
+      const eventTypes = [
+        PikkuEventTypes.http,
+        PikkuEventTypes.channel,
+        PikkuEventTypes.queue,
+        PikkuEventTypes.scheduler,
+        PikkuEventTypes.rpc,
+        PikkuEventTypes.mcp,
+      ]
+
+      eventTypes.forEach((eventType) => {
+        const filters: InspectorFilters = {
+          types: [eventType],
+        }
+
+        const result = matchesFilters(
+          filters,
+          { tags: ['test'] },
+          { type: eventType, name: 'test-route' },
+          mockLogger
+        )
+
+        assert.equal(result, true, `Should match for type: ${eventType}`)
+      })
+    })
+  })
+
+  describe('Directory filtering', () => {
+    test('should return true when directory matches', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api', 'src/internal'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when directory does not match', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api', 'src/internal'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/public/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle Windows paths correctly', () => {
+      const filters: InspectorFilters = {
+        directories: ['src\\api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: 'C:\\project\\src\\api\\routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should handle mixed path separators', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: 'C:\\project\\src\\api\\routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when filePath is not provided but directory filter exists', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' }, // no filePath
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle partial path matches', () => {
+      const filters: InspectorFilters = {
+        directories: ['api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/v1/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+  })
+
+  describe('Combined filtering', () => {
+    test('should return true when all filters pass', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+        types: ['http'],
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when type filter fails (even if others pass)', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+        types: ['channel'],
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should return false when directory filter fails (even if others pass)', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+        types: ['http'],
+        directories: ['src/internal'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should return false when tag filter fails (even if others pass)', () => {
+      const filters: InspectorFilters = {
+        tags: ['internal'],
+        types: ['http'],
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('Edge cases', () => {
+    test('should handle undefined params', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: undefined },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle empty meta name', () => {
+      const filters: InspectorFilters = {
+        types: ['channel'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: '' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle special characters in paths', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api-v2'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api-v2/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should handle case sensitivity in directory paths', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/API'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle multiple matching tags', () => {
+      const filters: InspectorFilters = {
+        tags: ['api', 'v1'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public', 'v1'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should handle multiple matching types', () => {
+      const filters: InspectorFilters = {
+        types: ['http', 'channel'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.channel, name: 'test-channel' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should handle multiple matching directories', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api', 'src/internal'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/internal/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+  })
+})

package/src/utils.ts

@@ -1,5 +1,6 @@
 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
@@ -843,16 +844,69 @@ export function getPropertyAssignmentInitializer(
 export const matchesFilters = (
   filters: InspectorFilters,
   params: { tags?: string[] },
-  meta: { type: 'schedule' | 'http' | 'channel'; name: string }
+  meta: {
+    type: PikkuEventTypes
+    name: string
+    filePath?: string
+  },
+  logger: InspectorLogger
 ) => {
-  if (Object.keys(filters).length === 0 || filters.tags?.length === 0) {
+  // 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/src/visit.ts

@@ -3,7 +3,11 @@ 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 { InspectorFilters, InspectorState } from './types.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 { InspectorFilters, InspectorState, InspectorLogger } from './types.js'
 import { addFunctions } from './add-functions.js'
 import { addChannel } from './add-channel.js'
 
@@ -11,7 +15,8 @@ export const visitSetup = (
   checker: ts.TypeChecker,
   node: ts.Node,
   state: InspectorState,
-  filters: InspectorFilters
+  filters: InspectorFilters,
+  logger: InspectorLogger
 ) => {
   addFileExtendsCoreType(
     node,
@@ -49,19 +54,28 @@ export const visitSetup = (
   )
 
   addFileWithFactory(node, checker, state.configFactories, 'CreateConfig')
-  addFunctions(node, checker, state, filters)
+  addFunctions(node, checker, state, filters, logger)
 
-  ts.forEachChild(node, (child) => visitSetup(checker, child, state, filters))
+  ts.forEachChild(node, (child) =>
+    visitSetup(checker, child, state, filters, logger)
+  )
 }
 
 export const visitRoutes = (
   checker: ts.TypeChecker,
   node: ts.Node,
   state: InspectorState,
-  filters: InspectorFilters
+  filters: InspectorFilters,
+  logger: InspectorLogger
 ) => {
-  addHTTPRoute(node, checker, state, filters)
-  addSchedule(node, checker, state, filters)
-  addChannel(node, checker, state, filters)
-  ts.forEachChild(node, (child) => visitRoutes(checker, child, state, filters))
+  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)
+  )
 }

package/tsconfig.json

@@ -2,7 +2,7 @@
   "extends": "../tsconfig.json",
   "compilerOptions": {
     "rootDir": "./src",
-    "module": "Node16",
+    "module": "Node18",
     "outDir": "dist",
     "target": "esnext",
     "declaration": true,