@pikku/inspector 0.12.34 → 0.12.35

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 0.12.35
+
+### Patch Changes
+
+- 7ebea62: Tree-shake addon registrations in filtered inspector states (per-unit deploy codegen).
+  - `filterInspectorState` drops an addon's `wireAddonDeclarations`/`usedAddons` unless something kept actually references it (kept wiring targeting `namespace:*`, kept agent/MCP tool, or a body-level `rpc.invoke('namespace:*')` from a file that still contains a kept function). The generated per-unit bootstrap no longer imports unused addon package bootstraps — previously every deploy unit registered every addon's entire function surface, which pulled dev-only code (e.g. `@pikku/addon-console`'s static `node:fs` imports) into Cloudflare Worker bundles and failed upload with `No such module "node:fs"`.
+  - Body-level `rpc.invoke()` targets are now tracked per source file (`rpc.invokedFunctionsByFile`) so wiring-level `ref()` targets no longer pin an addon into every unit.
+  - `aggregateRequiredServices` computes addon parent services per used addon function (from the addon's shipped per-function `services` meta) instead of blanket-adding `addonRequiredParentServices` — and matches namespaced ids only, so bare project function names colliding with addon function names no longer force the blanket.
+  - Addon builds keep per-function `services` in the shipped `pikku-functions-meta.gen.json` so parent projects can do the above; addons built before this fall back to the blanket.
+  - HTTP route meta records `refTarget` for `ref('namespace:fn')`-wired routes, so per-unit filtering keeps the addon registration (and only that function's services) when the route deploys.
+
+- Updated dependencies [7ebea62]
+- Updated dependencies [e57dd65]
+  - @pikku/core@0.12.51
+
 ## 0.12.34
 
 ### Patch Changes

package/dist/add/add-http-route.js

@@ -220,8 +220,10 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     const middleware = resolveHTTPMiddlewareFromObject(state, fullRoute, obj, tags, checker);
     // Resolve permissions
     const permissions = resolveHTTPPermissionsFromObject(state, fullRoute, obj, tags, checker);
-    // Track used functions/middleware/permissions for service aggregation
     state.serviceAggregation.usedFunctions.add(funcName);
+    if (refAddonTarget) {
+        state.serviceAggregation.usedFunctions.add(refAddonTarget);
+    }
     extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
     extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
     // Check for SSE
@@ -232,6 +234,7 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     state.http.files.add(sourceFile.fileName);
     state.http.meta[method][fullRoute] = {
         pikkuFuncId: funcName,
+        ...(refAddonTarget && { refTarget: refAddonTarget }),
         ...(packageName && { packageName }),
         route: fullRoute,
         sourceFile: sourceFile.fileName,

package/dist/add/add-rpc-invocations.js

@@ -85,10 +85,17 @@ export function addRPCInvocations(node, state, logger) {
                     const functionRef = firstArg.text;
                     logger.debug(`• Found RPC invocation: ${functionRef}`);
                     state.rpc.invokedFunctions.add(functionRef);
+                    let byFile = state.rpc.invokedFunctionsByFile.get(sourceFileName);
+                    if (!byFile) {
+                        byFile = new Set();
+                        state.rpc.invokedFunctionsByFile.set(sourceFileName, byFile);
+                    }
+                    byFile.add(functionRef);
                     const namespace = extractNamespace(functionRef);
                     if (namespace) {
                         logger.debug(`  → Addon detected: ${namespace}`);
                         state.rpc.usedAddons.add(namespace);
+                        state.serviceAggregation.usedFunctions.add(functionRef);
                     }
                 }
                 // Handle template literals like `function-${name}`

package/dist/inspector.js

@@ -93,6 +93,7 @@ export function getInitialInspectorState(rootDir) {
             exposedMeta: {},
             exposedFiles: new Map(),
             invokedFunctions: new Set(),
+            invokedFunctionsByFile: new Map(),
             usedAddons: new Set(),
             wireAddonDeclarations: new Map(),
             wireAddonFiles: new Set(),

package/dist/types.d.ts

@@ -413,6 +413,7 @@ export interface InspectorState {
             exportedName: string;
         }>;
         invokedFunctions: Set<string>;
+        invokedFunctionsByFile: Map<string, Set<string>>;
         usedAddons: Set<string>;
         wireAddonDeclarations: Map<string, {
             package: string;

package/dist/utils/filter-inspector-state.js

@@ -366,6 +366,9 @@ export function filterInspectorState(state, filters, logger) {
                 // Track used functions/middleware/permissions
                 if (routeMeta.pikkuFuncId) {
                     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(':');
@@ -796,6 +799,46 @@ export function filterInspectorState(state, filters, logger) {
     if (filteredState.serviceAggregation.requiredServices.has('workflowService')) {
         filteredState.serviceAggregation.requiredServices.add('queueService');
     }
+    if ((filteredState.rpc.wireAddonDeclarations?.size ?? 0) > 0) {
+        const referencedIds = new Set(filteredState.serviceAggregation.usedFunctions);
+        const keptFiles = new Set();
+        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()) {
+            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 ?? {})) {
+            if (toolMeta.pikkuFuncId)
+                referencedIds.add(toolMeta.pikkuFuncId);
+        }
+        for (const agentMeta of Object.values(filteredState.agents?.agentsMeta ?? {})) {
+            for (const tool of agentMeta.tools ?? [])
+                referencedIds.add(tool);
+        }
+        const keptNamespaces = new Set();
+        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;

package/dist/utils/load-addon-functions-meta.js

@@ -135,6 +135,7 @@ export async function loadAddonFunctionsMeta(logger, state) {
                 // 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`);
                 const addonMetaRaw = await readFile(addonMetaPath, 'utf-8');
@@ -144,24 +145,29 @@ export async function loadAddonFunctionsMeta(logger, state) {
                     state.addonServerlessIncompatible.set(namespace, addonMeta.serverlessIncompatible);
                     logger.debug(`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)) {
-                    for (const service of servicesModule.requiredParentServices) {
+                if (Array.isArray(addonMeta.requiredParentServices) &&
+                    addonMeta.requiredParentServices.length > 0) {
+                    for (const service of addonMeta.requiredParentServices) {
                         state.addonRequiredParentServices.push(service);
                     }
-                    logger.debug(`Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`);
+                    loadedParentServices = true;
+                    logger.debug(`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 {
                 const httpContractsPath = require.resolve(`${decl.package}/.pikku/http/pikku-http-contracts-meta.gen.json`);

package/dist/utils/post-process.js

@@ -253,19 +253,44 @@ export function aggregateRequiredServices(state) {
         requiredServices.add('eventHub');
     }
     // 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();
-    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();
+    for (const [namespace, fns] of Object.entries(state.addonFunctions ?? {})) {
+        for (const [id, meta] of Object.entries(fns)) {
+            addonFnServices.set(`${namespace}:${id}`, meta?.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);
         }
     }

package/dist/utils/serialize-inspector-state.d.ts

@@ -178,6 +178,7 @@ export interface SerializableInspectorState {
             exportedName: string;
         }]>;
         invokedFunctions: string[];
+        invokedFunctionsByFile?: Array<[string, string[]]>;
         usedAddons: string[];
         wireAddonDeclarations: Array<[
             string,

package/dist/utils/serialize-inspector-state.js

@@ -78,6 +78,7 @@ export function serializeInspectorState(state) {
             exposedMeta: state.rpc.exposedMeta,
             exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
             invokedFunctions: Array.from(state.rpc.invokedFunctions),
+            invokedFunctionsByFile: Array.from((state.rpc.invokedFunctionsByFile ?? new Map()).entries()).map(([file, fns]) => [file, Array.from(fns)]),
             usedAddons: Array.from(state.rpc.usedAddons),
             wireAddonDeclarations: Array.from(state.rpc.wireAddonDeclarations.entries()),
             wireAddonFiles: Array.from(state.rpc.wireAddonFiles),
@@ -235,6 +236,7 @@ export function deserializeInspectorState(data) {
             exposedMeta: data.rpc.exposedMeta,
             exposedFiles: new Map(data.rpc.exposedFiles),
             invokedFunctions: new Set(data.rpc.invokedFunctions),
+            invokedFunctionsByFile: new Map((data.rpc.invokedFunctionsByFile || []).map(([file, fns]) => [file, new Set(fns)])),
             usedAddons: new Set(data.rpc.usedAddons || []),
             wireAddonDeclarations: new Map(data.rpc.wireAddonDeclarations || []),
             wireAddonFiles: new Set(data.rpc.wireAddonFiles || []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.34",
+  "version": "0.12.35",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.50",
+    "@pikku/core": "^0.12.51",
     "openapi-types": "^12.1.3",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "2.9.1-next.16",

package/run-tests.sh

@@ -38,16 +38,16 @@ if [ ${#files[@]} -eq 0 ]; then
 fi
 
 # Construct the node command
-node_cmd="node --import tsx --test"
+node_cmd=(node --import tsx --test)
 
 # Append options based on flags
 if [ "$watch_mode" = true ]; then
-  node_cmd="$node_cmd --watch"
+  node_cmd+=(--watch)
 fi
 
 if [ "$coverage_mode" = true ]; then
-  node_cmd="$node_cmd --test-coverage-include=\"src/**/*.{ts,js}\" --test-coverage-exclude=\"**/dist/**\" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
+  node_cmd+=(--test-coverage-include="src/**/*.{ts,js}" --test-coverage-exclude="**/dist/**" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info)
 fi
 
 # Execute the node command with the expanded list of files
-$node_cmd "${files[@]}"
+"${node_cmd[@]}" "${files[@]}"

package/src/add/add-http-route.ts

@@ -389,8 +389,10 @@ export function registerHTTPRoute({
     checker
   )
 
-  // Track used functions/middleware/permissions for service aggregation
   state.serviceAggregation.usedFunctions.add(funcName)
+  if (refAddonTarget) {
+    state.serviceAggregation.usedFunctions.add(refAddonTarget)
+  }
   extractWireNames(middleware).forEach((name) =>
     state.serviceAggregation.usedMiddleware.add(name)
   )
@@ -415,6 +417,7 @@ export function registerHTTPRoute({
   state.http.files.add(sourceFile.fileName)
   state.http.meta[method][fullRoute] = {
     pikkuFuncId: funcName,
+    ...(refAddonTarget && { refTarget: refAddonTarget }),
     ...(packageName && { packageName }),
     route: fullRoute,
     sourceFile: sourceFile.fileName,

package/src/add/add-rpc-invocations.test.ts

@@ -0,0 +1,113 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { inspect } from '../inspector.js'
+import type { InspectorLogger, InspectorState } from '../types.js'
+
+function makeLogger(): InspectorLogger {
+  return {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    diagnostic: () => {},
+    critical: () => {},
+    hasCriticalErrors: () => false,
+  }
+}
+
+async function inspectFiles(
+  files: Record<string, string>
+): Promise<{ state: InspectorState; dir: string }> {
+  const dir = await mkdtemp(join(tmpdir(), 'pikku-rpc-invocations-test-'))
+  const paths: string[] = []
+  for (const [name, source] of Object.entries(files)) {
+    const path = join(dir, name)
+    await writeFile(path, source)
+    paths.push(path)
+  }
+  const state = await inspect(makeLogger(), paths, { rootDir: dir })
+  return { state, dir }
+}
+
+describe('add-rpc-invocations — invokedFunctionsByFile', () => {
+  test('body-level rpc.invoke() is attributed to its source file', async () => {
+    const { state, dir } = await inspectFiles({
+      'caller.ts': `
+declare const rpc: { invoke: (name: string, data?: unknown) => Promise<unknown> }
+export async function doWork() {
+  return rpc.invoke('console:getSchema')
+}
+`,
+      'other.ts': `
+export const unrelated = () => 'no invocations here'
+`,
+    })
+    try {
+      assert.ok(state.rpc.invokedFunctions.has('console:getSchema'))
+      const byFile = state.rpc.invokedFunctionsByFile
+      assert.strictEqual(byFile.size, 1)
+      const [file, invoked] = [...byFile.entries()][0]!
+      assert.ok(file.endsWith('caller.ts'))
+      assert.deepStrictEqual([...invoked], ['console:getSchema'])
+    } finally {
+      await rm(dir, { recursive: true, force: true })
+    }
+  })
+
+  test('namespaced body invoke joins serviceAggregation.usedFunctions', async () => {
+    const { state, dir } = await inspectFiles({
+      'caller.ts': `
+declare const rpc: { invoke: (name: string, data?: unknown) => Promise<unknown> }
+export async function doWork() {
+  await rpc.invoke('ext:goodbye')
+  return rpc.invoke('localHelper')
+}
+`,
+    })
+    try {
+      assert.ok(state.serviceAggregation.usedFunctions.has('ext:goodbye'))
+      assert.ok(!state.serviceAggregation.usedFunctions.has('localHelper'))
+    } finally {
+      await rm(dir, { recursive: true, force: true })
+    }
+  })
+
+  test('multiple invocations in one file accumulate under that file', async () => {
+    const { state, dir } = await inspectFiles({
+      'caller.ts': `
+declare const rpc: { invoke: (name: string, data?: unknown) => Promise<unknown> }
+export async function doWork() {
+  await rpc.invoke('console:getSchema')
+  return rpc.invoke('listTasks')
+}
+`,
+    })
+    try {
+      const invoked = [...state.rpc.invokedFunctionsByFile.values()][0]!
+      assert.deepStrictEqual([...invoked].sort(), [
+        'console:getSchema',
+        'listTasks',
+      ])
+    } finally {
+      await rm(dir, { recursive: true, force: true })
+    }
+  })
+
+  test('wiring-level ref() lands in invokedFunctions but NOT in the by-file map', async () => {
+    const { state, dir } = await inspectFiles({
+      'wiring.ts': `
+declare const ref: (name: string) => unknown
+export const routes = { stream: { func: ref('console:streamWorkflowRun') } }
+`,
+    })
+    try {
+      assert.ok(state.rpc.invokedFunctions.has('console:streamWorkflowRun'))
+      assert.strictEqual(state.rpc.invokedFunctionsByFile.size, 0)
+    } finally {
+      await rm(dir, { recursive: true, force: true })
+    }
+  })
+})

package/src/add/add-rpc-invocations.ts

@@ -115,10 +115,18 @@ export function addRPCInvocations(
           logger.debug(`• Found RPC invocation: ${functionRef}`)
           state.rpc.invokedFunctions.add(functionRef)
 
+          let byFile = state.rpc.invokedFunctionsByFile.get(sourceFileName)
+          if (!byFile) {
+            byFile = new Set()
+            state.rpc.invokedFunctionsByFile.set(sourceFileName, byFile)
+          }
+          byFile.add(functionRef)
+
           const namespace = extractNamespace(functionRef)
           if (namespace) {
             logger.debug(`  → Addon detected: ${namespace}`)
             state.rpc.usedAddons.add(namespace)
+            state.serviceAggregation.usedFunctions.add(functionRef)
           }
         }
         // Handle template literals like `function-${name}`

package/src/inspector.ts

@@ -124,6 +124,7 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       exposedMeta: {},
       exposedFiles: new Map(),
       invokedFunctions: new Set(),
+      invokedFunctionsByFile: new Map(),
       usedAddons: new Set(),
       wireAddonDeclarations: new Map(),
       wireAddonFiles: new Set(),

package/src/types.ts

@@ -482,6 +482,7 @@ export interface InspectorState {
     exposedMeta: Record<string, string>
     exposedFiles: Map<string, { path: string; exportedName: string }>
     invokedFunctions: Set<string>
+    invokedFunctionsByFile: Map<string, Set<string>>
     usedAddons: Set<string>
     wireAddonDeclarations: Map<
       string,