@pikku/inspector 0.11.0 → 0.11.2

package/CHANGELOG.md

@@ -1,11 +1,41 @@
-## 0.11.0
+## 0.11.2
+
+## 0.11.2
+
+### Patch Changes
+
+- db9c7bf: Add workflow graph inspection and DSL extraction
+- Updated dependencies [db9c7bf]
+  - @pikku/core@0.11.2
+
+### Features
+
+- f35e89da: Add workflow graph inspection and DSL extraction
+  - Workflow graph inspection with `add-workflow-graph.ts`
+  - DSL workflow extraction utilities (extract, deserialize, validate)
+  - DSL to graph conversion for metadata generation
+
+## 0.11.1
+
+### Patch Changes
+
+- 4b811db: chore: updating all dependencies
+- 28aeb7f: breaking: extract docs in the wiring meta
+- ce902b1: feat: adding in pikkuSimpleWorkflowFunc
+- 06e1a31: breaking: change session services to wire services
+- Updated dependencies [4b811db]
+- Updated dependencies [e12a00c]
+- Updated dependencies [4579434]
+- Updated dependencies [28aeb7f]
+- Updated dependencies [ce902b1]
+- Updated dependencies [06e1a31]
+  - @pikku/core@0.11.1
 
 ### Minor Changes
 
 - Add workflow inspection and analysis
 - Add enhanced type extraction utilities
 
-
 # @pikku/inspector
 
 ## 0.10.2

package/dist/add/add-channel.js

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
@@ -143,7 +143,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                         if (fnMeta) {
                                             // Resolve middleware for this route
                                             const routeTags = ts.isObjectLiteralExpression(init)
-                                                ? getPropertyTags(init, 'channel', channelKey, logger)
+                                                ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                                 : undefined;
                                             const routeMiddleware = ts.isObjectLiteralExpression(init)
                                                 ? resolveMiddleware(state, init, routeTags, checker)
@@ -165,7 +165,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                     if (fnMeta) {
                                         // Resolve middleware for this route
                                         const routeTags = ts.isObjectLiteralExpression(init)
-                                            ? getPropertyTags(init, 'channel', channelKey, logger)
+                                            ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                             : undefined;
                                         const routeMiddleware = ts.isObjectLiteralExpression(init)
                                             ? resolveMiddleware(state, init, routeTags, checker)
@@ -198,7 +198,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                 if (fnMeta) {
                                                     // Resolve middleware for this route
                                                     const routeTags = ts.isObjectLiteralExpression(init)
-                                                        ? getPropertyTags(init, 'channel', channelKey, logger)
+                                                        ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                                         : undefined;
                                                     const routeMiddleware = ts.isObjectLiteralExpression(init)
                                                         ? resolveMiddleware(state, init, routeTags, checker)
@@ -217,7 +217,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                 if (fnMeta) {
                                                     // Resolve middleware for this route
                                                     const routeTags = ts.isObjectLiteralExpression(init)
-                                                        ? getPropertyTags(init, 'channel', channelKey, logger)
+                                                        ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                                         : undefined;
                                                     const routeMiddleware = ts.isObjectLiteralExpression(init)
                                                         ? resolveMiddleware(state, init, routeTags, checker)
@@ -281,7 +281,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                             if (fnMeta) {
                                 // Resolve middleware for this route
                                 const routeTags = ts.isObjectLiteralExpression(init)
-                                    ? getPropertyTags(init, 'channel', channelKey, logger)
+                                    ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                     : undefined;
                                 const routeMiddleware = ts.isObjectLiteralExpression(init)
                                     ? resolveMiddleware(state, init, routeTags, checker)
@@ -310,7 +310,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
             // Resolve middleware and permissions for this route
             // Check if the route config is an object literal with middleware/permissions
             const routeTags = ts.isObjectLiteralExpression(init)
-                ? getPropertyTags(init, 'channel', channelKey, logger)
+                ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                 : undefined;
             const routeMiddleware = ts.isObjectLiteralExpression(init)
                 ? resolveMiddleware(state, init, routeTags, checker)
@@ -349,8 +349,7 @@ export const addChannel = (logger, node, checker, state, options) => {
             .keys.filter((k) => k.type === 'param')
             .map((k) => k.name)
         : [];
-    const docs = getPropertyValue(obj, 'docs');
-    const tags = getPropertyTags(obj, 'Channel', route, logger);
+    const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'Channel', name, logger);
     const query = getPropertyValue(obj, 'query');
     const connect = getPropertyAssignmentInitializer(obj, 'onConnect', true, checker);
     const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', true, checker);
@@ -421,7 +420,9 @@ export const addChannel = (logger, node, checker, state, options) => {
             : null,
         message,
         messageWirings,
-        docs: docs ?? undefined,
+        summary,
+        description,
+        errors,
         tags: tags ?? undefined,
         middleware,
     };

package/dist/add/add-file-with-factory.js

@@ -4,7 +4,7 @@ import { extractServicesFromFunction } from '../utils/extract-services.js';
 const wrapperFunctionMap = {
     pikkuConfig: 'CreateConfig',
     pikkuServices: 'CreateSingletonServices',
-    pikkuSessionServices: 'CreateSessionServices',
+    pikkuWireServices: 'CreateWireServices',
 };
 export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName, state) => {
     if (ts.isVariableDeclaration(node)) {
@@ -37,8 +37,8 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         typePath: typeDeclarationPath,
                     });
                     methods.set(fileName, variables);
-                    // Extract singleton services for CreateSessionServices factories
-                    if (expectedTypeName === 'CreateSessionServices' &&
+                    // Extract singleton services for CreateWireServices factories
+                    if (expectedTypeName === 'CreateWireServices' &&
                         state &&
                         callExpression.arguments.length > 0) {
                         const firstArg = callExpression.arguments[0];
@@ -51,7 +51,7 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         }
                         if (functionNode) {
                             const servicesMeta = extractServicesFromFunction(functionNode);
-                            state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                            state.wireServicesMeta.set(variableName, servicesMeta.services);
                         }
                     }
                     return; // Early return since we found a match
@@ -77,8 +77,8 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                     typePath: typeDeclarationPath,
                 });
                 methods.set(fileName, variables);
-                // Extract singleton services for CreateSessionServices factories
-                if (expectedTypeName === 'CreateSessionServices' &&
+                // Extract singleton services for CreateWireServices factories
+                if (expectedTypeName === 'CreateWireServices' &&
                     state &&
                     node.initializer) {
                     let functionNode;
@@ -90,7 +90,7 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                     }
                     if (functionNode) {
                         const servicesMeta = extractServicesFromFunction(functionNode);
-                        state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                        state.wireServicesMeta.set(variableName, servicesMeta.services);
                     }
                 }
             }
@@ -111,8 +111,8 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         typePath: typeDeclarationPath,
                     });
                     methods.set(fileName, variables);
-                    // Extract singleton services for CreateSessionServices factories
-                    if (expectedTypeName === 'CreateSessionServices' &&
+                    // Extract singleton services for CreateWireServices factories
+                    if (expectedTypeName === 'CreateWireServices' &&
                         state &&
                         node.initializer) {
                         let functionNode;
@@ -124,7 +124,7 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         }
                         if (functionNode) {
                             const servicesMeta = extractServicesFromFunction(functionNode);
-                            state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                            state.wireServicesMeta.set(variableName, servicesMeta.services);
                         }
                     }
                 }

package/dist/add/add-forge-credential.d.ts

@@ -0,0 +1,8 @@
+import { AddWiring } from '../types.js';
+/**
+ * Inspector for wireForgeCredential calls.
+ * Extracts metadata for Forge package credential declarations.
+ * Note: wireForgeCredential is metadata-only - no runtime behavior.
+ * Schema is stored as the variable name reference; actual Zod→JSON Schema conversion happens at CLI build time.
+ */
+export declare const addForgeCredential: AddWiring;

package/dist/add/add-forge-credential.js

@@ -0,0 +1,77 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { ErrorCode } from '../error-codes.js';
+/**
+ * Inspector for wireForgeCredential calls.
+ * Extracts metadata for Forge package credential declarations.
+ * Note: wireForgeCredential is metadata-only - no runtime behavior.
+ * Schema is stored as the variable name reference; actual Zod→JSON Schema conversion happens at CLI build time.
+ */
+export const addForgeCredential = (logger, node, _checker, state, _options) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    // Check if the call is to wireForgeCredential
+    if (!ts.isIdentifier(expression) ||
+        expression.text !== 'wireForgeCredential') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const nameValue = getPropertyValue(obj, 'name');
+        const displayNameValue = getPropertyValue(obj, 'displayName');
+        const descriptionValue = getPropertyValue(obj, 'description');
+        const secretIdValue = getPropertyValue(obj, 'secretId');
+        // Get schema variable name for later runtime import
+        let schemaVariableName = null;
+        for (const prop of obj.properties) {
+            if (ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'schema') {
+                if (ts.isIdentifier(prop.initializer)) {
+                    schemaVariableName = prop.initializer.text;
+                }
+                break;
+            }
+        }
+        // Validate required fields
+        if (!nameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, "Forge credential is missing the required 'name' property.");
+            return;
+        }
+        if (!displayNameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `Forge credential '${nameValue}' is missing the required 'displayName' property.`);
+            return;
+        }
+        if (!secretIdValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `Forge credential '${nameValue}' is missing the required 'secretId' property.`);
+            return;
+        }
+        if (!schemaVariableName) {
+            logger.critical(ErrorCode.MISSING_NAME, `Forge credential '${nameValue}' is missing the required 'schema' property or schema is not a variable reference.`);
+            return;
+        }
+        const sourceFile = node.getSourceFile().fileName;
+        state.forgeCredentials.files.add(sourceFile);
+        // Register the zod schema in the central zodLookup for deferred conversion
+        const schemaLookupName = `ForgeCredential_${nameValue}`;
+        state.zodLookup.set(schemaLookupName, {
+            variableName: schemaVariableName,
+            sourceFile,
+        });
+        // Store metadata - schema conversion happens later in schema-generator
+        state.forgeCredentials.meta[nameValue] = {
+            name: nameValue,
+            displayName: displayNameValue,
+            description: descriptionValue || undefined,
+            secretId: secretIdValue,
+            schema: schemaLookupName,
+        };
+    }
+};

package/dist/add/add-forge-node.d.ts

@@ -0,0 +1,7 @@
+import { AddWiring } from '../types.js';
+/**
+ * Inspector for wireForgeNode calls.
+ * Extracts metadata for Forge workflow builder nodes.
+ * Note: wireForgeNode is metadata-only - no runtime behavior.
+ */
+export declare const addForgeNode: AddWiring;

package/dist/add/add-forge-node.js

@@ -0,0 +1,77 @@
+import * as ts from 'typescript';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
+import { ErrorCode } from '../error-codes.js';
+/**
+ * Inspector for wireForgeNode calls.
+ * Extracts metadata for Forge workflow builder nodes.
+ * Note: wireForgeNode is metadata-only - no runtime behavior.
+ */
+export const addForgeNode = (logger, node, checker, state, _options) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    // Check if the call is to wireForgeNode
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireForgeNode') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const nameValue = getPropertyValue(obj, 'name');
+        const displayNameValue = getPropertyValue(obj, 'displayName');
+        const categoryValue = getPropertyValue(obj, 'category');
+        const typeValue = getPropertyValue(obj, 'type');
+        const rpcValue = getPropertyValue(obj, 'rpc');
+        const errorOutputValue = getPropertyValue(obj, 'errorOutput');
+        const { tags, description } = getCommonWireMetaData(obj, 'Forge node', nameValue, logger);
+        // Validate required fields
+        if (!nameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, "Forge node is missing the required 'name' property.");
+            return;
+        }
+        if (!displayNameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `Forge node '${nameValue}' is missing the required 'displayName' property.`);
+            return;
+        }
+        if (!categoryValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `Forge node '${nameValue}' is missing the required 'category' property.`);
+            return;
+        }
+        if (!typeValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `Forge node '${nameValue}' is missing the required 'type' property.`);
+            return;
+        }
+        if (!['trigger', 'action', 'end'].includes(typeValue)) {
+            logger.critical(ErrorCode.INVALID_VALUE, `Forge node '${nameValue}' has invalid type '${typeValue}'. Must be 'trigger', 'action', or 'end'.`);
+            return;
+        }
+        if (!rpcValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `Forge node '${nameValue}' is missing the required 'rpc' property.`);
+            return;
+        }
+        // Get function metadata for input/output schemas
+        const fnMeta = state.functions.meta[rpcValue];
+        const inputSchemaName = fnMeta?.inputs?.[0] || null;
+        const outputSchemaName = fnMeta?.outputs?.[0] || null;
+        // Note: Category validation against forge.node.categories config
+        // is done at CLI build time, not during inspection
+        state.forgeNodes.files.add(node.getSourceFile().fileName);
+        state.forgeNodes.meta[nameValue] = {
+            name: nameValue,
+            displayName: displayNameValue,
+            category: categoryValue,
+            type: typeValue,
+            rpc: rpcValue,
+            description,
+            errorOutput: errorOutputValue ?? false,
+            inputSchemaName,
+            outputSchemaName,
+            tags,
+        };
+    }
+};