@pikku/inspector 0.11.0 → 0.11.2

package/dist/add/add-workflow.js

@@ -1,20 +1,85 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
-import { getPropertyAssignmentInitializer, resolveFunctionDeclaration, } from '../utils/type-utils.js';
-import { resolveMiddleware } from '../utils/middleware.js';
-import { extractWireNames } from '../utils/post-process.js';
+import { extractFunctionNode } from '../utils/extract-function-node.js';
 import { ErrorCode } from '../error-codes.js';
-import { extractStringLiteral, extractNumberLiteral, extractPropertyString, isStringLike, isFunctionLike, } from '../utils/extract-node-value.js';
+import { extractStringLiteral, isStringLike, isFunctionLike, extractDescription, extractDuration, } from '../utils/extract-node-value.js';
+import { getCommonWireMetaData } from '../utils/get-property-value.js';
+import { extractDSLWorkflow } from '../utils/workflow/dsl/extract-dsl-workflow.js';
 /**
- * Scan for workflow.do() and workflow.sleep() calls to extract workflow steps
+ * Recursively check if any step has inline type (non-serializable)
+ */
+function hasInlineSteps(steps) {
+    for (const step of steps) {
+        if (step.type === 'inline') {
+            return true;
+        }
+        else if (step.type === 'branch') {
+            for (const branch of step.branches) {
+                if (hasInlineSteps(branch.steps))
+                    return true;
+            }
+            if (step.elseSteps && hasInlineSteps(step.elseSteps))
+                return true;
+        }
+        else if (step.type === 'switch' && step.cases) {
+            for (const c of step.cases) {
+                if (c.steps && hasInlineSteps(c.steps))
+                    return true;
+            }
+            if (step.defaultSteps && hasInlineSteps(step.defaultSteps))
+                return true;
+        }
+        else if (step.type === 'fanout' && step.child) {
+            if (hasInlineSteps([step.child]))
+                return true;
+        }
+        else if (step.type === 'parallel' && step.children) {
+            if (hasInlineSteps(step.children))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Recursively collect all RPC names from workflow steps
+ */
+function collectInvokedRPCs(steps, rpcs) {
+    for (const step of steps) {
+        if (step.type === 'rpc' && step.rpcName) {
+            rpcs.add(step.rpcName);
+        }
+        else if (step.type === 'branch') {
+            for (const branch of step.branches) {
+                collectInvokedRPCs(branch.steps, rpcs);
+            }
+            if (step.elseSteps)
+                collectInvokedRPCs(step.elseSteps, rpcs);
+        }
+        else if (step.type === 'switch' && step.cases) {
+            for (const c of step.cases) {
+                if (c.steps)
+                    collectInvokedRPCs(c.steps, rpcs);
+            }
+            if (step.defaultSteps)
+                collectInvokedRPCs(step.defaultSteps, rpcs);
+        }
+        else if (step.type === 'fanout' && step.child) {
+            collectInvokedRPCs([step.child], rpcs);
+        }
+        else if (step.type === 'parallel' && step.children) {
+            collectInvokedRPCs(step.children, rpcs);
+        }
+    }
+}
+/**
+ * Scan for workflow.do(), workflow.sleep(), and workflow.cancel() calls to extract workflow steps
  */
 function getWorkflowInvocations(node, checker, state, workflowName, steps) {
     // Look for property access expressions: workflow.do or workflow.sleep
     if (ts.isPropertyAccessExpression(node)) {
         const { name } = node;
         // Check if this is accessing 'do' or 'sleep' property
-        if (name.text === 'do' || name.text === 'sleep') {
+        if (name.text === 'do' || name.text === 'sleep' || name.text === 'cancel') {
             // Check if the parent is a call expression
             const parent = node.parent;
             if (ts.isCallExpression(parent) && parent.expression === node) {
@@ -34,7 +99,6 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                             type: 'rpc',
                             stepName,
                             rpcName,
-                            description,
                         });
                         state.rpc.invokedFunctions.add(rpcName);
                     }
@@ -59,94 +123,152 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                         duration: duration || '<dynamic>',
                     });
                 }
+                else if (name.text === 'cancel') {
+                    // workflow.cancel(reason?)
+                    steps.push({
+                        type: 'cancel',
+                    });
+                }
             }
         }
     }
-    // Don't recurse into nested functions - only look at top-level workflow calls
+    // Recurse into children, including arrow functions (for Promise.all callbacks)
+    // but skip function declarations (which would be separate functions)
     ts.forEachChild(node, (child) => {
-        if (ts.isFunctionDeclaration(child) ||
-            ts.isFunctionExpression(child) ||
-            ts.isArrowFunction(child)) {
+        if (ts.isFunctionDeclaration(child)) {
             return;
         }
         getWorkflowInvocations(child, checker, state, workflowName, steps);
     });
 }
 /**
- * Extract description from options object
- */
-function extractDescription(optionsNode, checker) {
-    if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
-        return null;
-    }
-    return extractPropertyString(optionsNode, 'description', checker);
-}
-/**
- * Extract duration value (number or string)
- */
-function extractDuration(node, checker) {
-    const numValue = extractNumberLiteral(node);
-    if (numValue !== null) {
-        return numValue;
-    }
-    return extractStringLiteral(node, checker);
-}
-/**
- * Inspector for wireWorkflow() calls
+ * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
  * Detects workflow registration and extracts metadata
  */
-export const addWorkflow = (logger, node, checker, state, options) => {
+export const addWorkflow = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
     const args = node.arguments;
     const firstArg = args[0];
     const expression = node.expression;
-    // Check if the call is to wireWorkflow
-    if (!ts.isIdentifier(expression) || expression.text !== 'wireWorkflow') {
+    if (!ts.isIdentifier(expression)) {
+        return;
+    }
+    let wrapperType = null;
+    if (expression.text === 'pikkuWorkflowFunc') {
+        wrapperType = 'dsl';
+    }
+    else if (expression.text === 'pikkuWorkflowComplexFunc') {
+        wrapperType = 'regular';
+    }
+    else {
         return;
     }
     if (!firstArg) {
         return;
     }
+    // Extract workflow name and metadata using same logic as add-functions
+    const { pikkuFuncName, name, exportedName } = extractFunctionName(node, checker, state.rootDir);
+    const workflowName = exportedName || name;
+    if (!workflowName) {
+        logger.critical(ErrorCode.MISSING_NAME, `Could not determine workflow name from export.`);
+        return;
+    }
+    // Extract the function node (either direct function or from config.func)
+    const { funcNode, resolvedFunc } = extractFunctionNode(firstArg, checker);
+    // Extract metadata if using object form
+    let tags;
+    let summary;
+    let description;
+    let errors;
     if (ts.isObjectLiteralExpression(firstArg)) {
-        const obj = firstArg;
-        const workflowName = getPropertyValue(obj, 'name');
-        const description = getPropertyValue(obj, 'description');
-        const docs = getPropertyValue(obj, 'docs') || undefined;
-        const tags = getPropertyTags(obj, 'Workflow', workflowName, logger);
-        // --- find the referenced function ---
-        const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
-        if (!workflowName) {
-            logger.critical(ErrorCode.MISSING_NAME, `Wasn't able to determine 'name' property for workflow wiring.`);
-            return;
+        const metadata = getCommonWireMetaData(firstArg, 'Workflow', workflowName, logger);
+        tags = metadata.tags;
+        summary = metadata.summary;
+        description = metadata.description;
+        errors = metadata.errors;
+    }
+    // Validate that we got a valid function
+    if (ts.isObjectLiteralExpression(firstArg) &&
+        (!funcNode || funcNode === firstArg)) {
+        logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for workflow '${workflowName}'.`);
+        return;
+    }
+    if (!resolvedFunc) {
+        logger.critical(ErrorCode.MISSING_FUNC, `Could not resolve workflow function for '${workflowName}'.`);
+        return;
+    }
+    // Track workflow file for wiring generation
+    if (exportedName) {
+        state.workflows.files.set(pikkuFuncName, {
+            path: node.getSourceFile().fileName,
+            exportedName,
+        });
+    }
+    let steps = [];
+    let context = undefined;
+    let dsl = undefined;
+    // Try DSL workflow extraction first
+    // Pass the whole CallExpression node so findWorkflowFunction can find the arrow function
+    const result = extractDSLWorkflow(node, checker);
+    if (result.status === 'ok' && result.steps) {
+        // Extraction succeeded
+        steps = result.steps;
+        context = result.context;
+        // Check if workflow contains inline steps (non-serializable)
+        if (hasInlineSteps(steps)) {
+            if (wrapperType === 'dsl') {
+                // pikkuWorkflowFunc should not have inline steps
+                logger.critical(ErrorCode.INVALID_DSL_WORKFLOW, `Workflow '${workflowName}' uses pikkuWorkflowFunc but contains inline steps which are not allowed in DSL workflows. Use pikkuWorkflowComplexFunc instead.`);
+                return;
+            }
+            // pikkuWorkflowComplexFunc with inline steps is marked as non-dsl
+            dsl = false;
         }
-        if (!funcInitializer) {
-            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for workflow '${workflowName}'.`);
-            return;
+        else {
+            // pikkuWorkflowComplexFunc is always non-dsl, pikkuWorkflowFunc is dsl
+            dsl = wrapperType === 'dsl';
+        }
+        // Collect all invoked RPCs from workflow steps
+        const rpcs = new Set();
+        collectInvokedRPCs(steps, rpcs);
+        for (const rpc of rpcs) {
+            state.rpc.invokedFunctions.add(rpc);
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
-        // --- resolve middleware ---
-        const middleware = resolveMiddleware(state, obj, tags, checker);
-        // --- track used functions/middleware for service aggregation ---
-        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
-        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
-        state.workflows.files.add(node.getSourceFile().fileName);
-        // Extract workflow steps from function body
-        // Resolve the identifier to the actual function declaration
-        const resolvedFunc = resolveFunctionDeclaration(funcInitializer, checker);
-        const steps = [];
-        if (resolvedFunc) {
+    }
+    else {
+        // DSL extraction failed
+        if (wrapperType === 'dsl') {
+            // For pikkuWorkflowFunc, this is a critical error
+            // But still track RPC invocations for function registration
             getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
+            logger.critical(ErrorCode.INVALID_DSL_WORKFLOW, `Workflow '${workflowName}' uses pikkuWorkflowFunc but does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`);
+            return;
+        }
+        else {
+            // For pikkuWorkflowComplexFunc, fall back to basic extraction
+            logger.debug(`Workflow '${workflowName}' could not be extracted as DSL workflow: ${result.reason || 'Unknown error'}. Falling back to basic extraction.`);
+            dsl = false;
         }
-        state.workflows.meta[workflowName] = {
-            pikkuFuncName,
-            workflowName,
-            description,
-            docs,
-            tags,
-            middleware,
-            steps,
-        };
     }
+    /**
+     * For non-dsl workflows or pikkuWorkflowComplexFunc, run basic extraction
+     * to ensure all RPC invocations are tracked for function registration.
+     * This catches RPCs in Promise.all callbacks and other patterns DSL can't extract.
+     */
+    if (!dsl || wrapperType === 'regular') {
+        getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
+    }
+    state.workflows.meta[workflowName] = {
+        pikkuFuncName,
+        workflowName,
+        steps,
+        context,
+        dsl,
+        summary,
+        description,
+        errors,
+        tags,
+    };
 };

package/dist/error-codes.d.ts

@@ -9,6 +9,7 @@
 export declare enum ErrorCode {
     MISSING_NAME = "PKU111",
     MISSING_DESCRIPTION = "PKU123",
+    INVALID_VALUE = "PKU124",
     MISSING_URI = "PKU220",
     MISSING_FUNC = "PKU236",
     INVALID_TAGS_TYPE = "PKU247",
@@ -19,11 +20,13 @@ export declare enum ErrorCode {
     CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = "PKU672",
     DYNAMIC_STEP_NAME = "PKU529",
     WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = "PKU600",
+    INVALID_DSL_WORKFLOW = "PKU641",
     CONFIG_TYPE_NOT_FOUND = "PKU426",
     CONFIG_TYPE_UNDEFINED = "PKU427",
     SCHEMA_NO_ROOT = "PKU431",
     SCHEMA_GENERATION_ERROR = "PKU456",
     SCHEMA_LOAD_ERROR = "PKU488",
+    INLINE_ZOD_SCHEMA = "PKU489",
     FUNCTION_METADATA_NOT_FOUND = "PKU559",
     HANDLER_NOT_RESOLVED = "PKU568",
     MIDDLEWARE_HANDLER_INVALID = "PKU685",

package/dist/error-codes.js

@@ -11,6 +11,7 @@ export var ErrorCode;
     // Validation errors
     ErrorCode["MISSING_NAME"] = "PKU111";
     ErrorCode["MISSING_DESCRIPTION"] = "PKU123";
+    ErrorCode["INVALID_VALUE"] = "PKU124";
     ErrorCode["MISSING_URI"] = "PKU220";
     ErrorCode["MISSING_FUNC"] = "PKU236";
     ErrorCode["INVALID_TAGS_TYPE"] = "PKU247";
@@ -21,12 +22,14 @@ export var ErrorCode;
     ErrorCode["CLI_CLIENTSIDE_RENDERER_HAS_SERVICES"] = "PKU672";
     ErrorCode["DYNAMIC_STEP_NAME"] = "PKU529";
     ErrorCode["WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED"] = "PKU600";
+    ErrorCode["INVALID_DSL_WORKFLOW"] = "PKU641";
     // Configuration errors
     ErrorCode["CONFIG_TYPE_NOT_FOUND"] = "PKU426";
     ErrorCode["CONFIG_TYPE_UNDEFINED"] = "PKU427";
     ErrorCode["SCHEMA_NO_ROOT"] = "PKU431";
     ErrorCode["SCHEMA_GENERATION_ERROR"] = "PKU456";
     ErrorCode["SCHEMA_LOAD_ERROR"] = "PKU488";
+    ErrorCode["INLINE_ZOD_SCHEMA"] = "PKU489";
     // Function errors
     ErrorCode["FUNCTION_METADATA_NOT_FOUND"] = "PKU559";
     ErrorCode["HANDLER_NOT_RESOLVED"] = "PKU568";

package/dist/index.d.ts

@@ -8,3 +8,8 @@ export { ErrorCode } from './error-codes.js';
 export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
 export type { SerializableInspectorState } from './utils/serialize-inspector-state.js';
 export { filterInspectorState } from './utils/filter-inspector-state.js';
+export { writeAllServiceMetadata } from './utils/write-service-metadata.js';
+export type { ServiceMetadata } from './utils/extract-service-metadata.js';
+export { convertAllDslToGraphs, convertDslToGraph, } from './utils/workflow/graph/convert-dsl-to-graph.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/deserialize-dsl-workflow.js';
+export type { SerializedWorkflowGraph } from './utils/workflow/graph/workflow-graph.types.js';

package/dist/index.js

@@ -3,3 +3,6 @@ export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export { ErrorCode } from './error-codes.js';
 export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
 export { filterInspectorState } from './utils/filter-inspector-state.js';
+export { writeAllServiceMetadata } from './utils/write-service-metadata.js';
+export { convertAllDslToGraphs, convertDslToGraph, } from './utils/workflow/graph/convert-dsl-to-graph.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/deserialize-dsl-workflow.js';

package/dist/inspector.js

@@ -4,7 +4,7 @@ import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
 import { getFilesAndMethods } from './utils/get-files-and-methods.js';
 import { findCommonAncestor } from './utils/find-root-dir.js';
-import { aggregateRequiredServices } from './utils/post-process.js';
+import { aggregateRequiredServices, extractServiceInterfaceMetadata, } from './utils/post-process.js';
 /**
  * Creates an initial/empty inspector state with all required properties initialized
  * @param rootDir - The root directory for the project
@@ -14,16 +14,17 @@ export function getInitialInspectorState(rootDir) {
     return {
         rootDir,
         singletonServicesTypeImportMap: new Map(),
-        sessionServicesTypeImportMap: new Map(),
+        wireServicesTypeImportMap: new Map(),
         userSessionTypeImportMap: new Map(),
         configTypeImportMap: new Map(),
         singletonServicesFactories: new Map(),
-        sessionServicesFactories: new Map(),
-        sessionServicesMeta: new Map(),
+        wireServicesFactories: new Map(),
+        wireServicesMeta: new Map(),
         configFactories: new Map(),
         filesAndMethods: {},
         filesAndMethodsErrors: new Map(),
         typesLookup: new Map(),
+        zodLookup: new Map(),
         functions: {
             typesMap: new TypesMap(),
             meta: {},
@@ -58,7 +59,9 @@ export function getInitialInspectorState(rootDir) {
         },
         workflows: {
             meta: {},
-            files: new Set(),
+            files: new Map(),
+            graphMeta: {},
+            graphFiles: new Map(),
         },
         rpc: {
             internalMeta: {},
@@ -66,6 +69,7 @@ export function getInitialInspectorState(rootDir) {
             exposedMeta: {},
             exposedFiles: new Map(),
             invokedFunctions: new Set(),
+            usedExternalPackages: new Set(),
         },
         mcpEndpoints: {
             resourcesMeta: {},
@@ -80,6 +84,14 @@ export function getInitialInspectorState(rootDir) {
             },
             files: new Set(),
         },
+        forgeNodes: {
+            meta: {},
+            files: new Set(),
+        },
+        forgeCredentials: {
+            meta: {},
+            files: new Set(),
+        },
         middleware: {
             meta: {},
             tagMiddleware: new Map(),
@@ -94,8 +106,9 @@ export function getInitialInspectorState(rootDir) {
             usedMiddleware: new Set(),
             usedPermissions: new Set(),
             allSingletonServices: [],
-            allSessionServices: [],
+            allWireServices: [],
         },
+        serviceMetadata: [],
     };
 }
 export const inspect = (logger, routeFiles, options = {}) => {
@@ -114,11 +127,15 @@ export const inspect = (logger, routeFiles, options = {}) => {
     const startChecker = performance.now();
     const checker = program.getTypeChecker();
     logger.debug(`Got type checker in ${(performance.now() - startChecker).toFixed(2)}ms`);
+    // Use provided rootDir or infer from source files
+    const rootDir = options.rootDir || findCommonAncestor(routeFiles);
     const startSourceFiles = performance.now();
-    const sourceFiles = program.getSourceFiles();
+    // Filter source files to only include files within the project rootDir
+    // This prevents picking up types from external packages (including workspace symlinks)
+    const sourceFiles = program
+        .getSourceFiles()
+        .filter((sf) => sf.fileName.startsWith(rootDir));
     logger.debug(`Got source files in ${(performance.now() - startSourceFiles).toFixed(2)}ms`);
-    // Infer root directory from source files
-    const rootDir = findCommonAncestor(routeFiles);
     const state = getInitialInspectorState(rootDir);
     // First sweep: add all functions
     const startSetup = performance.now();
@@ -144,6 +161,9 @@ export const inspect = (logger, routeFiles, options = {}) => {
         const startAggregate = performance.now();
         aggregateRequiredServices(state);
         logger.debug(`Aggregate required services completed in ${(performance.now() - startAggregate).toFixed(2)}ms`);
+        const startServiceMeta = performance.now();
+        extractServiceInterfaceMetadata(state, checker);
+        logger.debug(`Extract service metadata completed in ${(performance.now() - startServiceMeta).toFixed(2)}ms`);
     }
     return state;
 };

package/dist/types.d.ts

@@ -6,9 +6,11 @@ import { QueueWorkersMeta } from '@pikku/core/queue';
 import { WorkflowsMeta } from '@pikku/core/workflow';
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
 import { CLIMeta } from '@pikku/core/cli';
+import { ForgeNodesMeta, ForgeCredentialsMeta } from '@pikku/core/forge-node';
 import { TypesMap } from './types-map.js';
 import { FunctionsMeta, FunctionServicesMeta } from '@pikku/core';
 import { ErrorCode } from './error-codes.js';
+import type { SerializedWorkflowGraphs } from './utils/workflow/graph/workflow-graph.types.js';
 export type PathToNameAndType = Map<string, {
     variable: string;
     type: string | null;
@@ -42,6 +44,13 @@ export interface InspectorHTTPState {
     routeMiddleware: Map<string, MiddlewareGroupMeta>;
     routePermissions: Map<string, PermissionGroupMeta>;
 }
+/**
+ * Zod schema reference for deferred conversion to JSON Schema at build time
+ */
+export interface ZodSchemaRef {
+    variableName: string;
+    sourceFile: string;
+}
 export interface InspectorFunctionState {
     typesMap: TypesMap;
     meta: FunctionsMeta;
@@ -88,11 +97,13 @@ export type InspectorFilters = {
 };
 export type InspectorOptions = Partial<{
     setupOnly: boolean;
+    /** Project root directory - used to filter out external package files */
+    rootDir: string;
     types: Partial<{
         configFileType: string;
         userSessionType: string;
         singletonServicesFactoryType: string;
-        sessionServicesFactoryType: string;
+        wireServicesFactoryType: string;
     }>;
 }>;
 export interface InspectorLogger {
@@ -111,7 +122,7 @@ export interface InspectorFilesAndMethods {
         type: string;
         typePath: string;
     };
-    sessionServicesType?: {
+    wireServicesType?: {
         file: string;
         variable: string;
         type: string;
@@ -141,7 +152,7 @@ export interface InspectorFilesAndMethods {
         type: string;
         typePath: string;
     };
-    sessionServicesFactory?: {
+    wireServicesFactory?: {
         file: string;
         variable: string;
         type: string;
@@ -151,16 +162,17 @@ export interface InspectorFilesAndMethods {
 export interface InspectorState {
     rootDir: string;
     singletonServicesTypeImportMap: PathToNameAndType;
-    sessionServicesTypeImportMap: PathToNameAndType;
+    wireServicesTypeImportMap: PathToNameAndType;
     userSessionTypeImportMap: PathToNameAndType;
     configTypeImportMap: PathToNameAndType;
     singletonServicesFactories: PathToNameAndType;
-    sessionServicesFactories: PathToNameAndType;
-    sessionServicesMeta: Map<string, string[]>;
+    wireServicesFactories: PathToNameAndType;
+    wireServicesMeta: Map<string, string[]>;
     configFactories: PathToNameAndType;
     filesAndMethods: InspectorFilesAndMethods;
     filesAndMethodsErrors: Map<string, PathToNameAndType>;
     typesLookup: Map<string, ts.Type[]>;
+    zodLookup: Map<string, ZodSchemaRef>;
     http: InspectorHTTPState;
     functions: InspectorFunctionState;
     channels: InspectorChannelState;
@@ -174,7 +186,15 @@ export interface InspectorState {
     };
     workflows: {
         meta: WorkflowsMeta;
-        files: Set<string>;
+        files: Map<string, {
+            path: string;
+            exportedName: string;
+        }>;
+        graphMeta: SerializedWorkflowGraphs;
+        graphFiles: Map<string, {
+            path: string;
+            exportedName: string;
+        }>;
     };
     rpc: {
         internalMeta: Record<string, string>;
@@ -188,6 +208,7 @@ export interface InspectorState {
             exportedName: string;
         }>;
         invokedFunctions: Set<string>;
+        usedExternalPackages: Set<string>;
     };
     mcpEndpoints: {
         resourcesMeta: MCPResourceMeta;
@@ -199,6 +220,14 @@ export interface InspectorState {
         meta: CLIMeta;
         files: Set<string>;
     };
+    forgeNodes: {
+        meta: ForgeNodesMeta;
+        files: Set<string>;
+    };
+    forgeCredentials: {
+        meta: ForgeCredentialsMeta;
+        files: Set<string>;
+    };
     middleware: InspectorMiddlewareState;
     permissions: InspectorPermissionState;
     serviceAggregation: {
@@ -207,6 +236,16 @@ export interface InspectorState {
         usedMiddleware: Set<string>;
         usedPermissions: Set<string>;
         allSingletonServices: string[];
-        allSessionServices: string[];
+        allWireServices: string[];
     };
+    serviceMetadata: Array<{
+        name: string;
+        summary: string;
+        description: string;
+        package: string;
+        path: string;
+        version: string;
+        interface: string;
+        expandedProperties: Record<string, string>;
+    }>;
 }

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

@@ -274,9 +274,9 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                 for (const prop of firstArg.properties) {
                     if (ts.isPropertyAssignment(prop) &&
                         ts.isIdentifier(prop.name) &&
-                        prop.name.text === 'name' &&
+                        prop.name.text === 'override' &&
                         ts.isStringLiteral(prop.initializer)) {
-                        // Priority 1: Object with name property
+                        // Priority 1: Object with override property
                         result.explicitName = prop.initializer.text;
                         break;
                     }
@@ -475,15 +475,15 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                         // Update originalCallExpr to use the call expression position
                         // instead of the variable declaration position
                         originalCallExpr = decl.initializer;
-                        // Check for object with 'name' property in first argument
+                        // 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 === 'name' &&
+                                    prop.name.text === 'override' &&
                                     ts.isStringLiteral(prop.initializer)) {
-                                    // Priority 1: Object with name property
+                                    // Priority 1: Object with override property
                                     result.explicitName = prop.initializer.text;
                                     break;
                                 }
@@ -558,14 +558,14 @@ export function extractFunctionName(callExpr, checker, rootDir) {
         ts.isIdentifier(parent.name)) {
         result.propertyName = parent.name.text;
     }
-    // 3) Handle any remaining cases for pikkuFunc({ name: '…', func: … })
+    // 3) Handle any remaining cases for pikkuFunc({ override: '…', func: … })
     else if (ts.isCallExpression(originalCallExpr)) {
         const firstArg = originalCallExpr.arguments[0];
         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
             for (const prop of firstArg.properties) {
                 if (ts.isPropertyAssignment(prop) &&
                     ts.isIdentifier(prop.name) &&
-                    prop.name.text === 'name' &&
+                    prop.name.text === 'override' &&
                     ts.isStringLiteral(prop.initializer) &&
                     !result.explicitName // Only set if not already set
                 ) {