@pikku/inspector 0.12.34 → 0.12.35

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

@@ -234,6 +234,7 @@ function createMockInspectorState(): Omit<InspectorState, 'typesLookup'> {
       exposedMeta: {},
       exposedFiles: new Map(),
       invokedFunctions: new Set(),
+      invokedFunctionsByFile: new Map(),
     },
     mcpEndpoints: {
       toolsMeta: {
@@ -1657,3 +1658,233 @@ describe('addonServerlessIncompatible serialization roundtrip', () => {
     assert.strictEqual(restored.addonServerlessIncompatible.size, 0)
   })
 })
+
+describe('addon bootstrap tree-shake', () => {
+  const withAddon = (
+    mutate?: (state: Omit<InspectorState, 'typesLookup'>) => void
+  ) => {
+    const state = createMockInspectorState()
+    state.rpc.wireAddonDeclarations = new Map([
+      ['console', { package: '@pikku/addon-console' }],
+    ])
+    state.rpc.usedAddons = new Set(['console'])
+    state.rpc.invokedFunctions = new Set(['console:streamFunctionTests'])
+    mutate?.(state)
+    return state
+  }
+
+  test('drops an addon nothing kept references', () => {
+    const state = withAddon()
+    const filtered = filterInspectorState(
+      state,
+      { names: ['getUsers'] },
+      mockLogger
+    )
+    assert.strictEqual(filtered.rpc.wireAddonDeclarations.size, 0)
+    assert.strictEqual(filtered.rpc.usedAddons.size, 0)
+  })
+
+  test('keeps an addon when a kept wiring targets one of its functions', () => {
+    const state = withAddon((s) => {
+      s.http.meta.get['/console/stream'] = {
+        pikkuFuncId: 'console:streamFunctionTests',
+        route: '/console/stream',
+        method: 'GET',
+        tags: [],
+        middleware: [],
+        permissions: [],
+      } as any
+    })
+    const filtered = filterInspectorState(
+      state,
+      { names: ['console:streamFunctionTests'] },
+      mockLogger
+    )
+    assert.strictEqual(filtered.rpc.wireAddonDeclarations.size, 1)
+    assert.ok(filtered.rpc.wireAddonDeclarations.has('console'))
+  })
+
+  test('keeps an addon when a kept route ref()-targets one of its functions', () => {
+    const state = withAddon((s) => {
+      s.http.meta.get['/function-tests/stream'] = {
+        pikkuFuncId: 'http:get:/function-tests/stream',
+        refTarget: 'console:streamFunctionTests',
+        route: '/function-tests/stream',
+        method: 'GET',
+        tags: [],
+        middleware: [],
+        permissions: [],
+      } as any
+      s.functions.meta['http:get:/function-tests/stream'] = {
+        services: { optimized: false, services: [] },
+      } as any
+    })
+    const filtered = filterInspectorState(
+      state,
+      { names: ['http:get:/function-tests/stream'] },
+      mockLogger
+    )
+    assert.strictEqual(filtered.rpc.wireAddonDeclarations.size, 1)
+    assert.ok(filtered.rpc.wireAddonDeclarations.has('console'))
+    assert.ok(
+      filtered.serviceAggregation.usedFunctions.has(
+        'console:streamFunctionTests'
+      )
+    )
+  })
+
+  test('drops the addon when the ref()-wired route is filtered out', () => {
+    const state = withAddon((s) => {
+      s.http.meta.get['/function-tests/stream'] = {
+        pikkuFuncId: 'http:get:/function-tests/stream',
+        refTarget: 'console:streamFunctionTests',
+        route: '/function-tests/stream',
+        method: 'GET',
+        tags: [],
+        middleware: [],
+        permissions: [],
+      } as any
+      s.functions.meta['http:get:/function-tests/stream'] = {
+        services: { optimized: false, services: [] },
+      } as any
+    })
+    const filtered = filterInspectorState(
+      state,
+      { names: ['getUsers'] },
+      mockLogger
+    )
+    assert.strictEqual(filtered.rpc.wireAddonDeclarations.size, 0)
+    assert.ok(
+      !filtered.serviceAggregation.usedFunctions.has(
+        'console:streamFunctionTests'
+      )
+    )
+  })
+
+  test('keeps an addon when a kept MCP tool targets one of its functions', () => {
+    const state = withAddon((s) => {
+      s.mcpEndpoints.toolsMeta['console:getSchema'] = {
+        name: 'console:getSchema',
+        description: 'addon tool',
+        pikkuFuncId: 'console:getSchema',
+        tags: [],
+        middleware: [],
+        permissions: [],
+      } as any
+    })
+    const filtered = filterInspectorState(
+      state,
+      { names: ['console:getSchema'] },
+      mockLogger
+    )
+    assert.strictEqual(filtered.rpc.wireAddonDeclarations.size, 1)
+  })
+
+  test('keeps an addon when a kept agent lists one of its functions as a tool', () => {
+    const state = withAddon((s) => {
+      s.agents = s.agents ?? ({ agentsMeta: {} } as any)
+      s.agents.agentsMeta['support-agent'] = {
+        name: 'support-agent',
+        pikkuFuncId: 'supportAgent',
+        tools: ['console:getSchema'],
+        tags: [],
+      } as any
+    })
+    const filtered = filterInspectorState(
+      state,
+      { names: ['support-agent'] },
+      mockLogger
+    )
+    assert.strictEqual(filtered.rpc.wireAddonDeclarations.size, 1)
+  })
+
+  test('keeps an addon when a kept function body-invokes it', () => {
+    const state = withAddon((s) => {
+      s.rpc.invokedFunctionsByFile = new Map([
+        ['/test/project/src/api/users.ts', new Set(['console:getSchema'])],
+      ])
+    })
+    const filtered = filterInspectorState(
+      state,
+      { names: ['getUsers'] },
+      mockLogger
+    )
+    assert.strictEqual(filtered.rpc.wireAddonDeclarations.size, 1)
+  })
+
+  test('a kept-file body invoke joins the filtered usedFunctions', () => {
+    const state = withAddon((s) => {
+      s.rpc.invokedFunctionsByFile = new Map([
+        ['/test/project/src/api/users.ts', new Set(['console:getSchema'])],
+      ])
+    })
+    const filtered = filterInspectorState(
+      state,
+      { names: ['getUsers'] },
+      mockLogger
+    )
+    assert.ok(
+      filtered.serviceAggregation.usedFunctions.has('console:getSchema')
+    )
+  })
+
+  test('drops an addon body-invoked only from filtered-out files', () => {
+    const state = withAddon((s) => {
+      s.rpc.invokedFunctionsByFile = new Map([
+        ['/test/project/src/admin/settings.ts', new Set(['console:getSchema'])],
+      ])
+    })
+    const filtered = filterInspectorState(
+      state,
+      { names: ['getUsers'] },
+      mockLogger
+    )
+    assert.strictEqual(filtered.rpc.wireAddonDeclarations.size, 0)
+  })
+
+  test('unfiltered state keeps all addons', () => {
+    const state = withAddon()
+    const filtered = filterInspectorState(state, {}, mockLogger)
+    assert.strictEqual(filtered.rpc.wireAddonDeclarations.size, 1)
+  })
+})
+
+describe('invokedFunctionsByFile serialization', () => {
+  test('round-trips through serialize/deserialize', () => {
+    const state = getInitialInspectorState('/test/project')
+    state.rpc.invokedFunctionsByFile = new Map([
+      ['/test/project/src/api/users.ts', new Set(['console:getSchema'])],
+      [
+        '/test/project/src/api/tasks.ts',
+        new Set(['listTasks', 'console:runAgent']),
+      ],
+    ])
+    const restored = deserializeInspectorState(
+      JSON.parse(JSON.stringify(serializeInspectorState(state as any)))
+    )
+    assert.ok(restored.rpc.invokedFunctionsByFile instanceof Map)
+    assert.strictEqual(restored.rpc.invokedFunctionsByFile.size, 2)
+    assert.deepStrictEqual(
+      [
+        ...restored.rpc.invokedFunctionsByFile.get(
+          '/test/project/src/api/tasks.ts'
+        )!,
+      ].sort(),
+      ['console:runAgent', 'listTasks']
+    )
+  })
+
+  test('deserializing legacy state without the field yields an empty Map', () => {
+    const serialized = JSON.parse(
+      JSON.stringify(
+        serializeInspectorState(
+          getInitialInspectorState('/test/project') as any
+        )
+      )
+    )
+    delete serialized.rpc.invokedFunctionsByFile
+    const restored = deserializeInspectorState(serialized)
+    assert.ok(restored.rpc.invokedFunctionsByFile instanceof Map)
+    assert.strictEqual(restored.rpc.invokedFunctionsByFile.size, 0)
+  })
+})

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

@@ -468,6 +468,11 @@ export function filterInspectorState(
           filteredState.serviceAggregation.usedFunctions.add(
             routeMeta.pikkuFuncId
           )
+          if (routeMeta.refTarget) {
+            filteredState.serviceAggregation.usedFunctions.add(
+              routeMeta.refTarget
+            )
+          }
           // For workflow/agent routes, also add the base name
           // so the workflow/agent definition survives pruning
           const colonIdx = routeMeta.pikkuFuncId.indexOf(':')
@@ -1105,6 +1110,57 @@ export function filterInspectorState(
     filteredState.serviceAggregation.requiredServices.add('queueService')
   }
 
+  if ((filteredState.rpc.wireAddonDeclarations?.size ?? 0) > 0) {
+    const referencedIds = new Set<string>(
+      filteredState.serviceAggregation.usedFunctions
+    )
+    const keptFiles = new Set<string>()
+    for (const funcId of filteredState.serviceAggregation.usedFunctions) {
+      const file = filteredState.functions.files.get(funcId)
+      if (file?.path) keptFiles.add(file.path)
+    }
+    for (const [file, invoked] of state.rpc.invokedFunctionsByFile ??
+      new Map<string, Set<string>>()) {
+      if (!keptFiles.has(file)) continue
+      for (const id of invoked) {
+        referencedIds.add(id)
+        if (id.includes(':')) {
+          filteredState.serviceAggregation.usedFunctions.add(id)
+        }
+      }
+    }
+    for (const toolMeta of Object.values(
+      filteredState.mcpEndpoints?.toolsMeta ?? {}
+    ) as Array<{ pikkuFuncId?: string }>) {
+      if (toolMeta.pikkuFuncId) referencedIds.add(toolMeta.pikkuFuncId)
+    }
+    for (const agentMeta of Object.values(
+      filteredState.agents?.agentsMeta ?? {}
+    ) as Array<{ tools?: string[] }>) {
+      for (const tool of agentMeta.tools ?? []) referencedIds.add(tool)
+    }
+    const keptNamespaces = new Set<string>()
+    for (const namespace of filteredState.rpc.wireAddonDeclarations.keys()) {
+      const prefix = `${namespace}:`
+      for (const id of referencedIds) {
+        if (id.startsWith(prefix)) {
+          keptNamespaces.add(namespace)
+          break
+        }
+      }
+    }
+    filteredState.rpc.wireAddonDeclarations = new Map(
+      [...filteredState.rpc.wireAddonDeclarations].filter(([namespace]) =>
+        keptNamespaces.has(namespace)
+      )
+    )
+    filteredState.rpc.usedAddons = new Set(
+      [...filteredState.rpc.usedAddons].filter((namespace) =>
+        keptNamespaces.has(namespace)
+      )
+    )
+  }
+
   // Recalculate requiredServices based on filtered functions/middleware/permissions
   // Need to cast to InspectorState temporarily for aggregateRequiredServices
   const stateForAggregation = filteredState as InspectorState

package/src/utils/load-addon-functions-meta.ts

@@ -200,6 +200,7 @@ export async function loadAddonFunctionsMeta(
         // No variables meta — that's fine
       }
       // Load addon serverlessIncompatible service names from pikku-addon-meta.gen.json
+      let loadedParentServices = false
       try {
         const addonMetaPath = require.resolve(
           `${decl.package}/.pikku/console/pikku-addon-meta.gen.json`
@@ -218,29 +219,38 @@ export async function loadAddonFunctionsMeta(
             `Addon '${namespace}' marks [${addonMeta.serverlessIncompatible.join(', ')}] as serverless-incompatible`
           )
         }
-      } catch {
-        // No addon meta or no serverlessIncompatible declared — that's fine
-      }
-
-      // Load addon required parent services from pikku-services.gen
-      try {
-        const servicesGenPath = require.resolve(
-          `${decl.package}/.pikku/pikku-services.gen.js`
-        )
-        const servicesModule = await import(servicesGenPath)
         if (
-          servicesModule.requiredParentServices &&
-          Array.isArray(servicesModule.requiredParentServices)
+          Array.isArray(addonMeta.requiredParentServices) &&
+          addonMeta.requiredParentServices.length > 0
         ) {
-          for (const service of servicesModule.requiredParentServices) {
+          for (const service of addonMeta.requiredParentServices) {
             state.addonRequiredParentServices.push(service)
           }
+          loadedParentServices = true
           logger.debug(
-            `Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`
+            `Loaded ${addonMeta.requiredParentServices.length} required parent services for '${namespace}' from addon meta`
           )
         }
-      } catch {
-        // No services gen — addon may not have requiredParentServices
+      } catch {}
+
+      if (!loadedParentServices) {
+        try {
+          const servicesGenPath = require.resolve(
+            `${decl.package}/.pikku/pikku-services.gen.js`
+          )
+          const servicesModule = await import(servicesGenPath)
+          if (
+            servicesModule.requiredParentServices &&
+            Array.isArray(servicesModule.requiredParentServices)
+          ) {
+            for (const service of servicesModule.requiredParentServices) {
+              state.addonRequiredParentServices.push(service)
+            }
+            logger.debug(
+              `Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`
+            )
+          }
+        } catch {}
       }
 
       try {

package/src/utils/post-process.test.ts

@@ -0,0 +1,254 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { aggregateRequiredServices } from './post-process.js'
+import type { InspectorState } from '../types.js'
+
+function makeState(
+  overrides: {
+    usedFunctions?: string[]
+    functionsMeta?: Record<string, any>
+    addonFunctions?: Record<string, Record<string, any>>
+    addonRequiredParentServices?: string[]
+  } = {}
+): Omit<InspectorState, 'typesLookup'> {
+  return {
+    serviceAggregation: {
+      requiredServices: new Set<string>(),
+      usedFunctions: new Set(overrides.usedFunctions ?? []),
+      usedMiddleware: new Set<string>(),
+      usedPermissions: new Set<string>(),
+      allSingletonServices: [],
+      allWireServices: [],
+    },
+    functions: { meta: overrides.functionsMeta ?? {} },
+    middleware: { definitions: {}, tagMiddleware: new Map() },
+    permissions: { definitions: {}, tagPermissions: new Map() },
+    http: {
+      meta: {
+        get: {},
+        post: {},
+        put: {},
+        patch: {},
+        delete: {},
+        head: {},
+        options: {},
+      },
+      routeMiddleware: new Map(),
+      routePermissions: new Map(),
+    },
+    channels: { meta: {} },
+    queueWorkers: { meta: {} },
+    scheduledTasks: { meta: {} },
+    mcpEndpoints: { toolsMeta: {}, promptsMeta: {}, resourcesMeta: {} },
+    agents: { agentsMeta: {} },
+    workflows: { meta: {}, graphMeta: {} },
+    wireServicesMeta: new Map(),
+    rpc: { internalMeta: {}, exposedMeta: {} },
+    addonFunctions: overrides.addonFunctions ?? {},
+    addonRequiredParentServices: overrides.addonRequiredParentServices ?? [],
+  } as unknown as Omit<InspectorState, 'typesLookup'>
+}
+
+const CONSOLE_PARENT_SERVICES = [
+  'metaService',
+  'aiAgentRunner',
+  'deploymentService',
+  'credentialService',
+]
+
+describe('aggregateRequiredServices — per-function addon services', () => {
+  test('a used addon function adds only its own parent services', () => {
+    const state = makeState({
+      usedFunctions: ['console:getSchema'],
+      addonFunctions: {
+        console: {
+          getSchema: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+          runAgent: {
+            services: {
+              optimized: true,
+              services: ['aiAgentRunner', 'deploymentService'],
+            },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+    assert.ok(!required.has('deploymentService'))
+    assert.ok(!required.has('credentialService'))
+  })
+
+  test('an addon-created service falls back to the full parent blanket', () => {
+    const state = makeState({
+      usedFunctions: ['console:editCode'],
+      addonFunctions: {
+        console: {
+          editCode: {
+            services: {
+              optimized: true,
+              services: ['codeEditService', 'metaService'],
+            },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    for (const service of CONSOLE_PARENT_SERVICES) {
+      assert.ok(required.has(service), `expected blanket to add ${service}`)
+    }
+  })
+
+  test('missing services meta (old addon build) falls back to the blanket', () => {
+    const state = makeState({
+      usedFunctions: ['console:getSchema'],
+      addonFunctions: { console: { getSchema: {} } },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    for (const service of CONSOLE_PARENT_SERVICES) {
+      assert.ok(required.has(service), `expected blanket to add ${service}`)
+    }
+  })
+
+  test('a bare project function colliding with an addon function name adds nothing', () => {
+    const state = makeState({
+      usedFunctions: ['getAgentThreads'],
+      functionsMeta: {
+        getAgentThreads: {
+          services: { optimized: true, services: ['kysely'] },
+        },
+      },
+      addonFunctions: {
+        console: {
+          getAgentThreads: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('kysely'))
+    assert.ok(!required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+  })
+
+  test('no used addon functions adds no parent services', () => {
+    const state = makeState({
+      usedFunctions: ['listTasks'],
+      functionsMeta: {
+        listTasks: { services: { optimized: true, services: ['kysely'] } },
+      },
+      addonFunctions: {
+        console: {
+          getSchema: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(!required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+  })
+
+  test('internal services in addon function meta never force the blanket', () => {
+    const state = makeState({
+      usedFunctions: ['console:getSchema'],
+      addonFunctions: {
+        console: {
+          getSchema: {
+            services: {
+              optimized: true,
+              services: ['metaService', 'rpc', 'channel'],
+            },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+    assert.ok(!required.has('rpc'))
+  })
+
+  test('default framework services in addon function meta never force the blanket', () => {
+    const state = makeState({
+      usedFunctions: ['ext:goodbye'],
+      addonFunctions: {
+        ext: {
+          goodbye: {
+            services: { optimized: true, services: ['logger', 'config'] },
+          },
+        },
+      },
+      addonRequiredParentServices: ['greetingStore', 'auditSink'],
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(!required.has('greetingStore'))
+    assert.ok(!required.has('auditSink'))
+  })
+
+  test('a ref()-wired route (inline id + namespaced target) aggregates the target services', () => {
+    const state = makeState({
+      usedFunctions: [
+        'http:get:/function-tests/stream',
+        'console:streamFunctionTests',
+      ],
+      functionsMeta: {
+        'http:get:/function-tests/stream': {
+          services: { optimized: false, services: [] },
+        },
+      },
+      addonFunctions: {
+        console: {
+          streamFunctionTests: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+  })
+
+  test('multiple used addon functions union their parent services', () => {
+    const state = makeState({
+      usedFunctions: ['console:getSchema', 'console:runAgent'],
+      addonFunctions: {
+        console: {
+          getSchema: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+          runAgent: {
+            services: { optimized: true, services: ['aiAgentRunner'] },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('metaService'))
+    assert.ok(required.has('aiAgentRunner'))
+    assert.ok(!required.has('deploymentService'))
+    assert.ok(!required.has('credentialService'))
+  })
+})

package/src/utils/post-process.ts

@@ -325,20 +325,47 @@ export function aggregateRequiredServices(
   }
 
   // 7. Services that consumed addons need from the parent project.
-  // These are required ONLY by units that actually deploy an addon function;
-  // a unit that merely calls the addon over RPC (or never touches it) must not
-  // carry them, or every per-unit bundle would over-include the addon's
-  // parent-service dependencies (e.g. aiAgentRunner, deploymentService) and
-  // defeat per-unit tree-shaking.
-  const addonFuncIds = new Set<string>()
-  for (const fns of Object.values(state.addonFunctions ?? {})) {
-    for (const id of Object.keys(fns)) addonFuncIds.add(id)
-  }
-  const unitDeploysAddonFn = [...usedFunctions].some((fn) =>
-    addonFuncIds.has(fn)
-  )
-  if (unitDeploysAddonFn) {
-    for (const service of state.addonRequiredParentServices ?? []) {
+  const addonFnServices = new Map<string, string[] | undefined>()
+  for (const [namespace, fns] of Object.entries(state.addonFunctions ?? {})) {
+    for (const [id, meta] of Object.entries(fns)) {
+      addonFnServices.set(
+        `${namespace}:${id}`,
+        (meta as { services?: FunctionServicesMeta })?.services?.services
+      )
+    }
+  }
+  const parentDeclared = state.addonRequiredParentServices ?? []
+  const parentDeclaredSet = new Set(parentDeclared)
+  const defaultServices = new Set([
+    'config',
+    'logger',
+    'variables',
+    'schema',
+    'secrets',
+  ])
+  let usesAddonFn = false
+  let addonFactoryNeeded = false
+  for (const funcId of usedFunctions) {
+    if (!addonFnServices.has(funcId)) continue
+    usesAddonFn = true
+    const services = addonFnServices.get(funcId)
+    if (!services) {
+      addonFactoryNeeded = true
+      continue
+    }
+    for (const service of services) {
+      if (parentDeclaredSet.has(service)) {
+        requiredServices.add(service)
+      } else if (
+        !internalServices.has(service) &&
+        !defaultServices.has(service)
+      ) {
+        addonFactoryNeeded = true
+      }
+    }
+  }
+  if (usesAddonFn && addonFactoryNeeded) {
+    for (const service of parentDeclared) {
       requiredServices.add(service)
     }
   }