@pikku/inspector 0.12.8 → 0.12.9

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## 0.12.0
 
+## 0.12.9
+
+### Patch Changes
+
+- 2ac6468: Fix workflow inspector crash when workflow.do() data object has a 'description' property
+- fbcf5b9: Add version awareness to RPC handler: versioned functions now appear in the exposed RPC type map (e.g. `getData@v1`, `getData@v2`), enabling type-safe `rpc.invoke('getData@v1', data)` calls. Tree-shaking respects specific version filters without pulling in all versions. HTTP wirings correctly resolve versioned function IDs.
+- Updated dependencies [fbcf5b9]
+  - @pikku/core@0.12.16
+
 ## 0.12.8
 
 ### Patch Changes

package/dist/add/add-functions.js

@@ -615,15 +615,14 @@ export const addFunctions = (logger, node, checker, state, options) => {
     }
     if (mcpEnabled) {
         if (!description) {
-            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP tool '${name}' is missing a description.`);
-            return;
+            logger.warn(`MCP tool '${name}' is missing a description.`);
         }
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.toolsMeta[name] = {
             pikkuFuncId,
             name,
             title: title || undefined,
-            description,
+            description: description || undefined,
             summary,
             errors,
             tags,

package/dist/add/add-mcp-prompt.js

@@ -58,6 +58,10 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
+        if (!fnMeta.outputSchemaName) {
+            fnMeta.outputSchemaName = 'MCPPromptResponse';
+            fnMeta.outputs = ['MCPPromptResponse'];
+        }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
         // --- resolve permissions ---

package/dist/add/add-mcp-resource.js

@@ -67,6 +67,10 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
+        if (!fnMeta.outputSchemaName) {
+            fnMeta.outputSchemaName = 'MCPResourceResponse';
+            fnMeta.outputs = ['MCPResourceResponse'];
+        }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
         // --- resolve permissions ---

package/dist/add/add-workflow.js

@@ -88,7 +88,7 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                     // workflow.do(stepName, rpcName|fn, data?, options?)
                     const stepNameArg = args[0];
                     const secondArg = args[1];
-                    const optionsArg = args.length >= 3 ? args[args.length - 1] : undefined;
+                    const optionsArg = args.length >= 4 ? args[args.length - 1] : undefined;
                     const stepName = extractStringLiteral(stepNameArg, checker);
                     const description = extractDescription(optionsArg, checker) ?? undefined;
                     // Determine form by checking 2nd argument type

package/dist/utils/extract-function-name.d.ts

@@ -6,6 +6,7 @@ export type ExtractedFunctionName = {
     exportedName: string | null;
     propertyName: string | null;
     isHelper: boolean;
+    version: number | null;
 };
 export declare function makeContextBasedId(wiringType: string, ...segments: string[]): string;
 export declare function funcIdToTypeName(id: string): string;

package/dist/utils/extract-function-name.js

@@ -1,5 +1,6 @@
 import * as ts from 'typescript';
 import { randomUUID } from 'crypto';
+import { formatVersionedId } from '@pikku/core';
 export function makeContextBasedId(wiringType, ...segments) {
     return [wiringType, ...segments].join(':');
 }
@@ -20,6 +21,7 @@ export function extractFunctionName(callExpr, checker, rootDir) {
         propertyName: null,
         explicitName: null,
         isHelper: false,
+        version: null,
     };
     const workflowHelpers = new Set([
         'workflow',
@@ -103,16 +105,7 @@ export function extractFunctionName(callExpr, checker, rootDir) {
             // Check for object with 'name' property in first argument
             const firstArg = args[0];
             if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-                for (const prop of firstArg.properties) {
-                    if (ts.isPropertyAssignment(prop) &&
-                        ts.isIdentifier(prop.name) &&
-                        prop.name.text === 'override' &&
-                        ts.isStringLiteral(prop.initializer)) {
-                        // Priority 1: Object with override property
-                        result.explicitName = prop.initializer.text;
-                        break;
-                    }
-                }
+                extractOverrideAndVersion(firstArg, result);
             }
             // Special handling for pikkuSessionlessFunc pattern - use the arrow function directly
             if (expression.text.startsWith('pikku')) {
@@ -274,19 +267,9 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                     if (ts.isCallExpression(decl.initializer) &&
                         ts.isIdentifier(decl.initializer.expression) &&
                         decl.initializer.expression.text.startsWith('pikku')) {
-                        // Check for object with 'override' property in first argument
                         const firstArg = decl.initializer.arguments[0];
                         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-                            for (const prop of firstArg.properties) {
-                                if (ts.isPropertyAssignment(prop) &&
-                                    ts.isIdentifier(prop.name) &&
-                                    prop.name.text === 'override' &&
-                                    ts.isStringLiteral(prop.initializer)) {
-                                    // Priority 1: Object with override property
-                                    result.explicitName = prop.initializer.text;
-                                    break;
-                                }
-                            }
+                            extractOverrideAndVersion(firstArg, result);
                         }
                         if (decl.initializer.expression.text.startsWith('pikku')) {
                             if (firstArg &&
@@ -340,17 +323,7 @@ export function extractFunctionName(callExpr, checker, rootDir) {
     else if (ts.isCallExpression(callExpr)) {
         const firstArg = callExpr.arguments[0];
         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-            for (const prop of firstArg.properties) {
-                if (ts.isPropertyAssignment(prop) &&
-                    ts.isIdentifier(prop.name) &&
-                    prop.name.text === 'override' &&
-                    ts.isStringLiteral(prop.initializer) &&
-                    !result.explicitName // Only set if not already set
-                ) {
-                    result.explicitName = prop.initializer.text;
-                    break;
-                }
-            }
+            extractOverrideAndVersion(firstArg, result);
         }
     }
     // Apply name priority logic
@@ -364,6 +337,9 @@ export function extractFunctionName(callExpr, checker, rootDir) {
     else {
         result.pikkuFuncId = `__temp_${randomUUID()}`;
     }
+    if (result.version !== null) {
+        result.pikkuFuncId = formatVersionedId(result.pikkuFuncId, result.version);
+    }
     return result;
 }
 /**
@@ -420,3 +396,22 @@ export function isNamedExport(declaration, checker) {
     }
     return false;
 }
+function extractOverrideAndVersion(objLiteral, result) {
+    for (const prop of objLiteral.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            if (prop.name.text === 'override' &&
+                ts.isStringLiteral(prop.initializer) &&
+                !result.explicitName) {
+                result.explicitName = prop.initializer.text;
+            }
+            else if (prop.name.text === 'version' &&
+                ts.isNumericLiteral(prop.initializer) &&
+                result.version === null) {
+                const parsed = Number(prop.initializer.text);
+                if (Number.isInteger(parsed) && parsed >= 1) {
+                    result.version = parsed;
+                }
+            }
+        }
+    }
+}

package/dist/utils/extract-node-value.js

@@ -84,7 +84,12 @@ export function extractDescription(optionsNode, checker) {
     if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
         return null;
     }
-    return extractPropertyString(optionsNode, 'description', checker);
+    try {
+        return extractPropertyString(optionsNode, 'description', checker);
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Extract duration value (number or string)

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

@@ -532,11 +532,15 @@ export function filterInspectorState(state, filters, logger) {
             filteredState.serviceAggregation.usedFunctions.add(funcId);
         }
     }
-    // Post-filter version expansion: include all versions of matched functions
+    // Post-filter version expansion: when an unversioned base name is matched,
+    // include all its versions. Specific version matches (e.g. analyzeData@v1)
+    // do NOT expand to include other versions.
     const includedBaseNames = new Set();
     for (const funcId of filteredState.serviceAggregation.usedFunctions) {
-        const { baseName } = parseVersionedId(funcId);
-        includedBaseNames.add(baseName);
+        const { baseName, version } = parseVersionedId(funcId);
+        if (version === null) {
+            includedBaseNames.add(baseName);
+        }
     }
     if (includedBaseNames.size > 0) {
         for (const funcId of Object.keys(state.functions.meta)) {

package/dist/utils/resolve-versions.js

@@ -66,13 +66,43 @@ export function resolveLatestVersions(state, logger) {
             if (state.rpc.exposedMeta[baseName] === oldId) {
                 state.rpc.exposedMeta[baseName] = newId;
             }
+            updateWiringReferences(state, oldId, newId);
         }
         else {
             const latest = group.explicit.reduce((a, b) => a.version > b.version ? a : b);
             state.rpc.internalMeta[baseName] = latest.id;
         }
+        if (state.rpc.exposedMeta[baseName]) {
+            const latestId = state.rpc.internalMeta[baseName];
+            state.rpc.exposedMeta[baseName] = latestId;
+            for (const entry of group.explicit) {
+                state.rpc.exposedMeta[entry.id] = entry.id;
+                const fileEntry = state.rpc.internalFiles.get(entry.id);
+                if (fileEntry) {
+                    state.rpc.exposedFiles.set(entry.id, fileEntry);
+                }
+            }
+            if (group.unversioned) {
+                state.rpc.exposedMeta[latestId] = latestId;
+                const fileEntry = state.rpc.internalFiles.get(latestId);
+                if (fileEntry) {
+                    state.rpc.exposedFiles.set(latestId, fileEntry);
+                }
+            }
+        }
         for (const entry of group.explicit) {
             state.rpc.invokedFunctions.add(entry.id);
         }
     }
 }
+function updateWiringReferences(state, oldId, newId) {
+    if (state.http) {
+        for (const methods of Object.values(state.http.meta)) {
+            for (const meta of Object.values(methods)) {
+                if (meta.pikkuFuncId === oldId) {
+                    meta.pikkuFuncId = newId;
+                }
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.8",
+  "version": "0.12.9",
   "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.15",
+    "@pikku/core": "^0.12.16",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",

package/src/add/add-functions.ts

@@ -817,18 +817,16 @@ export const addFunctions: AddWiring = (
 
   if (mcpEnabled) {
     if (!description) {
-      logger.critical(
-        ErrorCode.MISSING_DESCRIPTION,
+      logger.warn(
         `MCP tool '${name}' is missing a description.`
       )
-      return
     }
     state.mcpEndpoints.files.add(node.getSourceFile().fileName)
     state.mcpEndpoints.toolsMeta[name] = {
       pikkuFuncId,
       name,
       title: title || undefined,
-      description,
+      description: description || undefined,
       summary,
       errors,
       tags,

package/src/add/add-mcp-prompt.ts

@@ -114,6 +114,11 @@ export const addMCPPrompt: AddWiring = (
     const inputSchema = fnMeta.inputs?.[0] || null
     const outputSchema = fnMeta.outputs?.[0] || null
 
+    if (!fnMeta.outputSchemaName) {
+      fnMeta.outputSchemaName = 'MCPPromptResponse'
+      fnMeta.outputs = ['MCPPromptResponse']
+    }
+
     // --- resolve middleware ---
     const middleware = resolveMiddleware(state, obj, tags, checker)
 

package/src/add/add-mcp-resource.ts

@@ -131,6 +131,11 @@ export const addMCPResource: AddWiring = (
     const inputSchema = fnMeta.inputs?.[0] || null
     const outputSchema = fnMeta.outputs?.[0] || null
 
+    if (!fnMeta.outputSchemaName) {
+      fnMeta.outputSchemaName = 'MCPResourceResponse'
+      fnMeta.outputs = ['MCPResourceResponse']
+    }
+
     // --- resolve middleware ---
     const middleware = resolveMiddleware(state, obj, tags, checker)
 

package/src/add/add-workflow.ts

@@ -97,7 +97,7 @@ function getWorkflowInvocations(
           const stepNameArg = args[0]
           const secondArg = args[1]
           const optionsArg =
-            args.length >= 3 ? args[args.length - 1] : undefined
+            args.length >= 4 ? args[args.length - 1] : undefined
 
           const stepName = extractStringLiteral(stepNameArg, checker)
           const description =

package/src/utils/extract-function-name.ts

@@ -1,5 +1,6 @@
 import * as ts from 'typescript'
 import { randomUUID } from 'crypto'
+import { formatVersionedId } from '@pikku/core'
 
 export type ExtractedFunctionName = {
   pikkuFuncId: string
@@ -8,6 +9,7 @@ export type ExtractedFunctionName = {
   exportedName: string | null
   propertyName: string | null
   isHelper: boolean
+  version: number | null
 }
 
 export function makeContextBasedId(
@@ -40,6 +42,7 @@ export function extractFunctionName(
     propertyName: null,
     explicitName: null,
     isHelper: false,
+    version: null,
   }
 
   const workflowHelpers = new Set([
@@ -143,18 +146,7 @@ export function extractFunctionName(
       // Check for object with 'name' property in first argument
       const firstArg = args[0]
       if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-        for (const prop of firstArg.properties) {
-          if (
-            ts.isPropertyAssignment(prop) &&
-            ts.isIdentifier(prop.name) &&
-            prop.name.text === 'override' &&
-            ts.isStringLiteral(prop.initializer)
-          ) {
-            // Priority 1: Object with override property
-            result.explicitName = prop.initializer.text
-            break
-          }
-        }
+        extractOverrideAndVersion(firstArg, result)
       }
 
       // Special handling for pikkuSessionlessFunc pattern - use the arrow function directly
@@ -367,21 +359,9 @@ export function extractFunctionName(
             ts.isIdentifier(decl.initializer.expression) &&
             decl.initializer.expression.text.startsWith('pikku')
           ) {
-            // Check for object with 'override' property in first argument
             const firstArg = decl.initializer.arguments[0]
             if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-              for (const prop of firstArg.properties) {
-                if (
-                  ts.isPropertyAssignment(prop) &&
-                  ts.isIdentifier(prop.name) &&
-                  prop.name.text === 'override' &&
-                  ts.isStringLiteral(prop.initializer)
-                ) {
-                  // Priority 1: Object with override property
-                  result.explicitName = prop.initializer.text
-                  break
-                }
-              }
+              extractOverrideAndVersion(firstArg, result)
             }
 
             if (decl.initializer.expression.text.startsWith('pikku')) {
@@ -448,18 +428,7 @@ export function extractFunctionName(
   else if (ts.isCallExpression(callExpr)) {
     const firstArg = callExpr.arguments[0]
     if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-      for (const prop of firstArg.properties) {
-        if (
-          ts.isPropertyAssignment(prop) &&
-          ts.isIdentifier(prop.name) &&
-          prop.name.text === 'override' &&
-          ts.isStringLiteral(prop.initializer) &&
-          !result.explicitName // Only set if not already set
-        ) {
-          result.explicitName = prop.initializer.text
-          break
-        }
-      }
+      extractOverrideAndVersion(firstArg, result)
     }
   }
 
@@ -474,6 +443,10 @@ export function extractFunctionName(
     result.pikkuFuncId = `__temp_${randomUUID()}`
   }
 
+  if (result.version !== null) {
+    result.pikkuFuncId = formatVersionedId(result.pikkuFuncId, result.version)
+  }
+
   return result
 }
 
@@ -539,3 +512,29 @@ export function isNamedExport(
 
   return false
 }
+
+function extractOverrideAndVersion(
+  objLiteral: ts.ObjectLiteralExpression,
+  result: ExtractedFunctionName
+): void {
+  for (const prop of objLiteral.properties) {
+    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+      if (
+        prop.name.text === 'override' &&
+        ts.isStringLiteral(prop.initializer) &&
+        !result.explicitName
+      ) {
+        result.explicitName = prop.initializer.text
+      } else if (
+        prop.name.text === 'version' &&
+        ts.isNumericLiteral(prop.initializer) &&
+        result.version === null
+      ) {
+        const parsed = Number(prop.initializer.text)
+        if (Number.isInteger(parsed) && parsed >= 1) {
+          result.version = parsed
+        }
+      }
+    }
+  }
+}

package/src/utils/extract-node-value.test.ts

@@ -0,0 +1,67 @@
+import { test, describe } from 'node:test'
+import { strict as assert } from 'node:assert'
+import * as ts from 'typescript'
+import { extractDescription } from './extract-node-value'
+
+const createChecker = (source: string) => {
+  const sourceFile = ts.createSourceFile(
+    'test.ts',
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  )
+  const host = ts.createCompilerHost({})
+  const originalGetSourceFile = host.getSourceFile
+  host.getSourceFile = (fileName, target) => {
+    if (fileName === 'test.ts') return sourceFile
+    return originalGetSourceFile.call(host, fileName, target)
+  }
+  const program = ts.createProgram(['test.ts'], {}, host)
+  return { checker: program.getTypeChecker(), sourceFile }
+}
+
+const findObjectLiteral = (
+  node: ts.Node
+): ts.ObjectLiteralExpression | undefined => {
+  if (ts.isObjectLiteralExpression(node)) return node
+  let result: ts.ObjectLiteralExpression | undefined
+  ts.forEachChild(node, (child) => {
+    if (!result) result = findObjectLiteral(child)
+  })
+  return result
+}
+
+describe('extractDescription', () => {
+  test('returns null when node is undefined', () => {
+    const { checker } = createChecker('')
+    assert.equal(extractDescription(undefined, checker), null)
+  })
+
+  test('extracts string literal description', () => {
+    const { checker, sourceFile } = createChecker(
+      `const opts = { description: 'my step' }`
+    )
+    const obj = findObjectLiteral(sourceFile)!
+    assert.equal(extractDescription(obj, checker), 'my step')
+  })
+
+  test('returns null for non-literal description value without crashing', () => {
+    const { checker, sourceFile } = createChecker(
+      `const name = 'test'; const data = { description: name + ' addon' }`
+    )
+    const objs: ts.ObjectLiteralExpression[] = []
+    const visit = (node: ts.Node) => {
+      if (ts.isObjectLiteralExpression(node)) objs.push(node)
+      ts.forEachChild(node, visit)
+    }
+    ts.forEachChild(sourceFile, visit)
+    const dataObj = objs[objs.length - 1]!
+    assert.equal(extractDescription(dataObj, checker), null)
+  })
+
+  test('returns null for non-object node', () => {
+    const { checker, sourceFile } = createChecker(`const x = 42`)
+    assert.equal(extractDescription(sourceFile, checker), null)
+  })
+})

package/src/utils/extract-node-value.ts

@@ -110,7 +110,11 @@ export function extractDescription(
   if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
     return null
   }
-  return extractPropertyString(optionsNode, 'description', checker)
+  try {
+    return extractPropertyString(optionsNode, 'description', checker)
+  } catch {
+    return null
+  }
 }
 
 /**

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

@@ -730,11 +730,15 @@ export function filterInspectorState(
     }
   }
 
-  // Post-filter version expansion: include all versions of matched functions
+  // Post-filter version expansion: when an unversioned base name is matched,
+  // include all its versions. Specific version matches (e.g. analyzeData@v1)
+  // do NOT expand to include other versions.
   const includedBaseNames = new Set<string>()
   for (const funcId of filteredState.serviceAggregation.usedFunctions) {
-    const { baseName } = parseVersionedId(funcId)
-    includedBaseNames.add(baseName)
+    const { baseName, version } = parseVersionedId(funcId)
+    if (version === null) {
+      includedBaseNames.add(baseName)
+    }
   }
   if (includedBaseNames.size > 0) {
     for (const funcId of Object.keys(state.functions.meta)) {