@pikku/inspector 0.12.10 → 0.12.12

package/src/utils/filter-inspector-state.ts

@@ -6,6 +6,7 @@ import type {
 import type { PikkuWiringTypes } from '@pikku/core'
 import { parseVersionedId } from '@pikku/core'
 import { aggregateRequiredServices } from './post-process.js'
+import { resolveDeployTarget } from './resolve-deploy-target.js'
 
 // Module-level Set to track warned groups across multiple filter calls
 const globalWarnedGroups = new Set<string>()
@@ -35,6 +36,59 @@ function matchesWildcard(value: string, pattern: string): boolean {
   return value === pattern
 }
 
+function collectSourceFiles(
+  value: unknown,
+  sourceFiles = new Set<string>(),
+  seen = new Set<object>()
+): Set<string> {
+  if (typeof value === 'string') {
+    return sourceFiles
+  }
+
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectSourceFiles(entry, sourceFiles, seen)
+    }
+    return sourceFiles
+  }
+
+  if (!value || typeof value !== 'object') {
+    return sourceFiles
+  }
+
+  if (seen.has(value)) {
+    return sourceFiles
+  }
+  seen.add(value)
+
+  if ('sourceFile' in value && typeof value.sourceFile === 'string') {
+    sourceFiles.add(value.sourceFile)
+  }
+
+  for (const nestedValue of Object.values(value)) {
+    collectSourceFiles(nestedValue, sourceFiles, seen)
+  }
+
+  return sourceFiles
+}
+
+function repopulateFileSetFromMeta(
+  meta: unknown,
+  fallbackFiles: Set<string>,
+  hasEntries: boolean
+): Set<string> {
+  const sourceFiles = collectSourceFiles(meta)
+  if (sourceFiles.size > 0) {
+    return sourceFiles
+  }
+
+  if (hasEntries) {
+    return new Set(fallbackFiles)
+  }
+
+  return new Set<string>()
+}
+
 /**
  * Check if metadata matches the given filters
  */
@@ -50,7 +104,10 @@ function matchesFilters(
     groupBasePath?: string
   },
   logger: InspectorLogger,
-  warnedGroups?: Set<string>
+  warnedGroups?: Set<string>,
+  // Set of pikkuFuncIds to keep based on the deploy filter; null when
+  // the deploy filter is inactive.
+  keptByDeploy?: Set<string> | null
 ): boolean {
   // If no filters, allow everything
   if (Object.keys(filters).length === 0) return true
@@ -59,18 +116,41 @@ function matchesFilters(
   if (
     (!filters.names || filters.names.length === 0) &&
     (!filters.tags || filters.tags.length === 0) &&
-    (!filters.types || filters.types.length === 0) &&
+    (!filters.wires || filters.wires.length === 0) &&
+    (!filters.excludeWires || filters.excludeWires.length === 0) &&
     (!filters.directories || filters.directories.length === 0) &&
     (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
-    (!filters.httpMethods || filters.httpMethods.length === 0)
+    (!filters.httpMethods || filters.httpMethods.length === 0) &&
+    (!filters.target || filters.target.length === 0) &&
+    (!filters.excludeNames || filters.excludeNames.length === 0) &&
+    (!filters.excludeTags || filters.excludeTags.length === 0) &&
+    (!filters.excludeWires || filters.excludeWires.length === 0) &&
+    (!filters.excludeDirectories || filters.excludeDirectories.length === 0) &&
+    (!filters.excludeHttpRoutes || filters.excludeHttpRoutes.length === 0) &&
+    (!filters.excludeHttpMethods || filters.excludeHttpMethods.length === 0) &&
+    (!filters.excludeTarget || filters.excludeTarget.length === 0)
   ) {
     return true
   }
 
-  // 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}`)
+  // Deploy-target include filter (computed once per filterInspectorState call).
+  if (keptByDeploy && !keptByDeploy.has(meta.name)) {
+    logger.debug(`⒡ Filtered by deploy include: ${meta.type}:${meta.name}`)
+    return false
+  }
+
+  // Check wire include filter
+  if (filters.wires && filters.wires.length > 0) {
+    if (!filters.wires.includes(meta.type)) {
+      logger.debug(`⒡ Filtered by wire include: ${meta.type}:${meta.name}`)
+      return false
+    }
+  }
+
+  // Check wire exclude filter
+  if (filters.excludeWires && filters.excludeWires.length > 0) {
+    if (filters.excludeWires.includes(meta.type)) {
+      logger.debug(`⒡ Filtered by wire exclude: ${meta.type}:${meta.name}`)
       return false
     }
   }
@@ -89,35 +169,55 @@ function matchesFilters(
     }
   }
 
-  // Check tag filter
+  // Check tag include filter
   if (filters.tags && filters.tags.length > 0) {
     if (!meta.tags || !filters.tags.some((tag) => meta.tags!.includes(tag))) {
-      logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`)
+      logger.debug(`⒡ Filtered by tags include: ${meta.type}:${meta.name}`)
       return false
     }
   }
 
-  // Check name filter (match against both full ID and base name for versioned functions)
+  // Check tag exclude filter
+  if (filters.excludeTags && filters.excludeTags.length > 0) {
+    if (
+      meta.tags &&
+      filters.excludeTags.some((tag) => meta.tags!.includes(tag))
+    ) {
+      logger.debug(`⒡ Filtered by tags exclude: ${meta.type}:${meta.name}`)
+      return false
+    }
+  }
+
+  const { baseName } = parseVersionedId(meta.name)
+  const matchesNamePattern = (pattern: string) =>
+    matchesWildcard(meta.name, pattern) ||
+    (baseName !== meta.name && matchesWildcard(baseName, pattern))
+
+  // Check name include filter (match against both full ID and base name for versioned functions)
   if (filters.names && filters.names.length > 0) {
-    const { baseName } = parseVersionedId(meta.name)
-    const nameMatches = filters.names.some(
-      (pattern) =>
-        matchesWildcard(meta.name, pattern) ||
-        (baseName !== meta.name && matchesWildcard(baseName, pattern))
-    )
+    const nameMatches = filters.names.some(matchesNamePattern)
     if (!nameMatches) {
-      logger.debug(`⒡ Filtered by name: ${meta.type}:${meta.name}`)
+      logger.debug(`⒡ Filtered by name include: ${meta.type}:${meta.name}`)
+      return false
+    }
+  }
+
+  // Check name exclude filter
+  if (filters.excludeNames && filters.excludeNames.length > 0) {
+    if (filters.excludeNames.some(matchesNamePattern)) {
+      logger.debug(`⒡ Filtered by name exclude: ${meta.type}:${meta.name}`)
       return false
     }
   }
 
-  // Check HTTP route filter
+  const matchesRoutePattern = (pattern: string) =>
+    !!meta.httpRoute && matchesWildcard(meta.httpRoute, pattern)
+
+  // Check HTTP route include filter
   if (filters.httpRoutes && filters.httpRoutes.length > 0 && meta.httpRoute) {
-    const routeMatches = filters.httpRoutes.some((pattern) =>
-      matchesWildcard(meta.httpRoute!, pattern)
-    )
+    const routeMatches = filters.httpRoutes.some(matchesRoutePattern)
     if (!routeMatches) {
-      logger.debug(`⒡ Filtered by HTTP route: ${meta.httpRoute}`)
+      logger.debug(`⒡ Filtered by HTTP route include: ${meta.httpRoute}`)
       return false
     }
 
@@ -139,15 +239,40 @@ function matchesFilters(
     }
   }
 
-  // Check HTTP method filter
+  // Check HTTP route exclude filter
+  if (
+    filters.excludeHttpRoutes &&
+    filters.excludeHttpRoutes.length > 0 &&
+    meta.httpRoute
+  ) {
+    if (filters.excludeHttpRoutes.some(matchesRoutePattern)) {
+      logger.debug(`⒡ Filtered by HTTP route exclude: ${meta.httpRoute}`)
+      return false
+    }
+  }
+
+  const normalizedMethod = meta.httpMethod?.toUpperCase()
+
+  // Check HTTP method include filter
   if (
     filters.httpMethods &&
     filters.httpMethods.length > 0 &&
-    meta.httpMethod
+    normalizedMethod
   ) {
-    const normalizedMethod = meta.httpMethod.toUpperCase()
     if (!filters.httpMethods.includes(normalizedMethod)) {
-      logger.debug(`⒡ Filtered by HTTP method: ${meta.httpMethod}`)
+      logger.debug(`⒡ Filtered by HTTP method include: ${meta.httpMethod}`)
+      return false
+    }
+  }
+
+  // Check HTTP method exclude filter
+  if (
+    filters.excludeHttpMethods &&
+    filters.excludeHttpMethods.length > 0 &&
+    normalizedMethod
+  ) {
+    if (filters.excludeHttpMethods.includes(normalizedMethod)) {
+      logger.debug(`⒡ Filtered by HTTP method exclude: ${meta.httpMethod}`)
       return false
     }
   }
@@ -183,14 +308,47 @@ export function filterInspectorState(
     Object.keys(filters).length === 0 ||
     ((!filters.names || filters.names.length === 0) &&
       (!filters.tags || filters.tags.length === 0) &&
-      (!filters.types || filters.types.length === 0) &&
+      (!filters.wires || filters.wires.length === 0) &&
+      (!filters.excludeWires || filters.excludeWires.length === 0) &&
       (!filters.directories || filters.directories.length === 0) &&
       (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
-      (!filters.httpMethods || filters.httpMethods.length === 0))
+      (!filters.httpMethods || filters.httpMethods.length === 0) &&
+      (!filters.target || filters.target.length === 0) &&
+      (!filters.excludeNames || filters.excludeNames.length === 0) &&
+      (!filters.excludeTags || filters.excludeTags.length === 0) &&
+      (!filters.excludeWires || filters.excludeWires.length === 0) &&
+      (!filters.excludeDirectories ||
+        filters.excludeDirectories.length === 0) &&
+      (!filters.excludeHttpRoutes || filters.excludeHttpRoutes.length === 0) &&
+      (!filters.excludeHttpMethods ||
+        filters.excludeHttpMethods.length === 0) &&
+      (!filters.excludeTarget || filters.excludeTarget.length === 0))
   ) {
     return state
   }
 
+  // Precompute kept-function set for the deploy filter (if active).
+  // resolveDeployTarget throws IncompatibleDeployTargetError when an
+  // explicit deploy: 'serverless' clashes with serverlessIncompatible.
+  let keptByDeploy: Set<string> | null = null
+  if (
+    (filters.target && filters.target.length > 0) ||
+    (filters.excludeTarget && filters.excludeTarget.length > 0)
+  ) {
+    const allowed = filters.target ? new Set(filters.target) : null
+    const excluded = filters.excludeTarget
+      ? new Set(filters.excludeTarget)
+      : null
+    const incompatible = new Set(filters.serverlessIncompatible ?? [])
+    keptByDeploy = new Set<string>()
+    for (const [funcId, funcMeta] of Object.entries(state.functions.meta)) {
+      const target = resolveDeployTarget(funcMeta as any, incompatible, funcId)
+      if (allowed && !allowed.has(target)) continue
+      if (excluded && excluded.has(target)) continue
+      keptByDeploy.add(funcId)
+    }
+  }
+
   // Snapshot the original workflow graph meta before filtering prunes it
   const originalGraphMeta = {
     ...((state as InspectorState).workflows?.graphMeta ?? {}),
@@ -292,7 +450,8 @@ export function filterInspectorState(
           groupBasePath: routeMeta.groupBasePath,
         },
         logger,
-        globalWarnedGroups
+        globalWarnedGroups,
+        keptByDeploy
       )
 
       if (!matches) {
@@ -356,7 +515,11 @@ export function filterInspectorState(
         name,
         tags: channelMeta.tags,
       },
-      logger
+      logger,
+
+      undefined,
+
+      keptByDeploy
     )
 
     if (!matches) {
@@ -405,10 +568,11 @@ export function filterInspectorState(
     }
   }
 
-  // Repopulate channels.files if any channels remain
-  if (Object.keys(filteredState.channels.meta).length > 0) {
-    filteredState.channels.files = new Set(state.channels.files)
-  }
+  filteredState.channels.files = repopulateFileSetFromMeta(
+    filteredState.channels.meta,
+    state.channels.files,
+    Object.keys(filteredState.channels.meta).length > 0
+  )
 
   // Filter triggers
   for (const name of Object.keys(filteredState.triggers.meta)) {
@@ -420,7 +584,11 @@ export function filterInspectorState(
         name,
         tags: triggerMeta.tags,
       },
-      logger
+      logger,
+
+      undefined,
+
+      keptByDeploy
     )
 
     if (!matches) {
@@ -434,10 +602,11 @@ export function filterInspectorState(
     }
   }
 
-  // Repopulate triggers.files if any triggers remain
-  if (Object.keys(filteredState.triggers.meta).length > 0) {
-    filteredState.triggers.files = new Set(state.triggers.files)
-  }
+  filteredState.triggers.files = repopulateFileSetFromMeta(
+    filteredState.triggers.meta,
+    state.triggers.files,
+    Object.keys(filteredState.triggers.meta).length > 0
+  )
 
   // Filter scheduled tasks
   for (const name of Object.keys(filteredState.scheduledTasks.meta)) {
@@ -449,7 +618,11 @@ export function filterInspectorState(
         name,
         tags: taskMeta.tags,
       },
-      logger
+      logger,
+
+      undefined,
+
+      keptByDeploy
     )
 
     if (!matches) {
@@ -464,10 +637,11 @@ export function filterInspectorState(
     }
   }
 
-  // Repopulate scheduledTasks.files if any tasks remain
-  if (Object.keys(filteredState.scheduledTasks.meta).length > 0) {
-    filteredState.scheduledTasks.files = new Set(state.scheduledTasks.files)
-  }
+  filteredState.scheduledTasks.files = repopulateFileSetFromMeta(
+    filteredState.scheduledTasks.meta,
+    state.scheduledTasks.files,
+    Object.keys(filteredState.scheduledTasks.meta).length > 0
+  )
 
   // Filter queue workers
   for (const name of Object.keys(filteredState.queueWorkers.meta)) {
@@ -479,7 +653,11 @@ export function filterInspectorState(
         name,
         tags: workerMeta.tags,
       },
-      logger
+      logger,
+
+      undefined,
+
+      keptByDeploy
     )
 
     if (!matches) {
@@ -502,10 +680,11 @@ export function filterInspectorState(
     }
   }
 
-  // Repopulate queueWorkers.files if any workers remain
-  if (Object.keys(filteredState.queueWorkers.meta).length > 0) {
-    filteredState.queueWorkers.files = new Set(state.queueWorkers.files)
-  }
+  filteredState.queueWorkers.files = repopulateFileSetFromMeta(
+    filteredState.queueWorkers.meta,
+    state.queueWorkers.files,
+    Object.keys(filteredState.queueWorkers.meta).length > 0
+  )
 
   // Filter MCP tools
   for (const name of Object.keys(filteredState.mcpEndpoints.toolsMeta)) {
@@ -517,7 +696,11 @@ export function filterInspectorState(
         name,
         tags: toolMeta.tags,
       },
-      logger
+      logger,
+
+      undefined,
+
+      keptByDeploy
     )
 
     if (!matches) {
@@ -545,7 +728,11 @@ export function filterInspectorState(
         name,
         tags: resourceMeta.tags,
       },
-      logger
+      logger,
+
+      undefined,
+
+      keptByDeploy
     )
 
     if (!matches) {
@@ -575,7 +762,11 @@ export function filterInspectorState(
         name,
         tags: promptMeta.tags,
       },
-      logger
+      logger,
+
+      undefined,
+
+      keptByDeploy
     )
 
     if (!matches) {
@@ -595,14 +786,20 @@ export function filterInspectorState(
     }
   }
 
-  // Repopulate mcpEndpoints.files if any MCP endpoints remain
+  // Repopulate mcpEndpoints.files from surviving endpoint metadata
   const hasMcpEndpoints =
     Object.keys(filteredState.mcpEndpoints.toolsMeta).length > 0 ||
     Object.keys(filteredState.mcpEndpoints.resourcesMeta).length > 0 ||
     Object.keys(filteredState.mcpEndpoints.promptsMeta).length > 0
-  if (hasMcpEndpoints) {
-    filteredState.mcpEndpoints.files = new Set(state.mcpEndpoints.files)
-  }
+  filteredState.mcpEndpoints.files = repopulateFileSetFromMeta(
+    {
+      toolsMeta: filteredState.mcpEndpoints.toolsMeta,
+      resourcesMeta: filteredState.mcpEndpoints.resourcesMeta,
+      promptsMeta: filteredState.mcpEndpoints.promptsMeta,
+    },
+    state.mcpEndpoints.files,
+    hasMcpEndpoints
+  )
 
   // Filter AI agents
   for (const name of Object.keys(filteredState.agents.agentsMeta)) {
@@ -614,7 +811,11 @@ export function filterInspectorState(
         name,
         tags: agentMeta.tags,
       },
-      logger
+      logger,
+
+      undefined,
+
+      keptByDeploy
     )
 
     if (!matches) {
@@ -654,7 +855,11 @@ export function filterInspectorState(
           name: commandName,
           tags: commandMeta.tags,
         },
-        logger
+        logger,
+
+        undefined,
+
+        keptByDeploy
       )
 
       if (!matches) {
@@ -690,13 +895,15 @@ export function filterInspectorState(
     }
   }
 
-  // Repopulate cli.files if any CLI programs or referenced renderers remain
+  // Repopulate cli.files from surviving program/renderer metadata
   const hasCliPrograms = Object.keys(filteredState.cli.meta.programs).length > 0
   const hasCliRenderers =
     Object.keys(filteredState.cli.meta.renderers || {}).length > 0
-  if (hasCliPrograms || hasCliRenderers) {
-    filteredState.cli.files = new Set(state.cli.files)
-  }
+  filteredState.cli.files = repopulateFileSetFromMeta(
+    filteredState.cli.meta,
+    state.cli.files,
+    hasCliPrograms || hasCliRenderers
+  )
 
   // Direct function filtering: functions that match the names/tags/directories
   // filters should be included even if no wiring (HTTP, scheduler, etc.) references them.
@@ -722,7 +929,11 @@ export function filterInspectorState(
         tags: funcMeta.tags,
         filePath,
       },
-      logger
+      logger,
+
+      undefined,
+
+      keptByDeploy
     )
 
     if (matches) {
@@ -786,12 +997,17 @@ export function filterInspectorState(
       }
     }
 
-    // Prune workflow graphs whose function was filtered out
+    // Prune workflow graphs whose function was filtered out — UNLESS the
+    // workflow's own name is in the filter (covers pikkuWorkflowGraph,
+    // which doesn't register a function meta, so its pikkuFuncId never
+    // ends up in usedFunctions even when callers explicitly want it).
+    const filterNamesSet = new Set(filters.names ?? [])
     const workflowKeys = new Set([
       ...Object.keys(filteredState.workflows.graphMeta),
       ...Object.keys(filteredState.workflows.meta),
     ])
     for (const name of workflowKeys) {
+      if (filterNamesSet.has(name)) continue
       const graphMeta = filteredState.workflows.graphMeta[name]
       const workflowMeta = filteredState.workflows.meta[name]
       // Check both graphMeta.pikkuFuncId and meta.pikkuFuncId
@@ -866,6 +1082,16 @@ export function filterInspectorState(
     }
   }
 
+  // workflowService internally calls queueService (via queueStepWorker /
+  // queueOrchestrator). Any unit that needs workflowService also needs
+  // queueService for the transitive enqueue calls — covers
+  // workflow-starter, graph-starter, workflow-runner, etc.
+  if (
+    filteredState.serviceAggregation.requiredServices.has('workflowService')
+  ) {
+    filteredState.serviceAggregation.requiredServices.add('queueService')
+  }
+
   // Recalculate requiredServices based on filtered functions/middleware/permissions
   // Need to cast to InspectorState temporarily for aggregateRequiredServices
   const stateForAggregation = filteredState as InspectorState

package/src/utils/filter-utils.test.ts

@@ -31,7 +31,7 @@ describe('matchesFilters', () => {
     test('should return true when all filter arrays are empty', () => {
       const filters: InspectorFilters = {
         tags: [],
-        types: [],
+        wires: [],
         directories: [],
       }
 
@@ -108,10 +108,10 @@ describe('matchesFilters', () => {
     })
   })
 
-  describe('Type filtering', () => {
-    test('should return true when type matches', () => {
+  describe('Wire filtering', () => {
+    test('should return true when wire matches', () => {
       const filters: InspectorFilters = {
-        types: ['http', 'channel'],
+        wires: ['http', 'channel'],
       }
 
       const result = matchesFilters(
@@ -124,9 +124,9 @@ describe('matchesFilters', () => {
       assert.equal(result, true)
     })
 
-    test('should return false when type does not match', () => {
+    test('should return false when wire does not match', () => {
       const filters: InspectorFilters = {
-        types: ['channel', 'queue'],
+        wires: ['channel', 'queue'],
       }
 
       const result = matchesFilters(
@@ -144,7 +144,7 @@ describe('matchesFilters', () => {
 
       eventTypes.forEach((eventType) => {
         const filters: InspectorFilters = {
-          types: [eventType],
+          wires: [eventType],
         }
 
         const result = matchesFilters(
@@ -154,9 +154,24 @@ describe('matchesFilters', () => {
           mockLogger
         )
 
-        assert.equal(result, true, `Should match for type: ${eventType}`)
+        assert.equal(result, true, `Should match for wire: ${eventType}`)
       })
     })
+
+    test('should exclude matching wires', () => {
+      const filters: InspectorFilters = {
+        excludeWires: ['queue', 'scheduler'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: 'queue', name: 'email-worker' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
   })
 
   describe('Directory filtering', () => {
@@ -275,7 +290,7 @@ describe('matchesFilters', () => {
     test('should return true when all filters pass', () => {
       const filters: InspectorFilters = {
         tags: ['api'],
-        types: ['http'],
+        wires: ['http'],
         directories: ['src/api'],
       }
 
@@ -296,7 +311,7 @@ describe('matchesFilters', () => {
     test('should return false when type filter fails (even if others pass)', () => {
       const filters: InspectorFilters = {
         tags: ['api'],
-        types: ['channel'],
+        wires: ['channel'],
         directories: ['src/api'],
       }
 
@@ -317,7 +332,7 @@ describe('matchesFilters', () => {
     test('should return false when directory filter fails (even if others pass)', () => {
       const filters: InspectorFilters = {
         tags: ['api'],
-        types: ['http'],
+        wires: ['http'],
         directories: ['src/internal'],
       }
 
@@ -338,7 +353,7 @@ describe('matchesFilters', () => {
     test('should return false when tag filter fails (even if others pass)', () => {
       const filters: InspectorFilters = {
         tags: ['internal'],
-        types: ['http'],
+        wires: ['http'],
         directories: ['src/api'],
       }
 
@@ -375,7 +390,7 @@ describe('matchesFilters', () => {
 
     test('should handle empty meta name', () => {
       const filters: InspectorFilters = {
-        types: ['channel'],
+        wires: ['channel'],
       }
 
       const result = matchesFilters(
@@ -443,7 +458,7 @@ describe('matchesFilters', () => {
 
     test('should handle multiple matching types', () => {
       const filters: InspectorFilters = {
-        types: ['http', 'channel'],
+        wires: ['http', 'channel'],
       }
 
       const result = matchesFilters(
@@ -724,7 +739,7 @@ describe('matchesFilters', () => {
     test('should return true when all filters including new ones pass', () => {
       const filters: InspectorFilters = {
         tags: ['api'],
-        types: ['http'],
+        wires: ['http'],
         httpRoutes: ['/api/*'],
         httpMethods: ['GET'],
       }