@pikku/inspector 0.11.2 → 0.12.1

package/dist/add/add-workflow.js

@@ -169,7 +169,7 @@ export const addWorkflow = (logger, node, checker, state) => {
         return;
     }
     // Extract workflow name and metadata using same logic as add-functions
-    const { pikkuFuncName, name, exportedName } = extractFunctionName(node, checker, state.rootDir);
+    const { pikkuFuncId, 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.`);
@@ -184,6 +184,8 @@ export const addWorkflow = (logger, node, checker, state) => {
     let errors;
     if (ts.isObjectLiteralExpression(firstArg)) {
         const metadata = getCommonWireMetaData(firstArg, 'Workflow', workflowName, logger);
+        if (metadata.disabled)
+            return;
         tags = metadata.tags;
         summary = metadata.summary;
         description = metadata.description;
@@ -201,7 +203,7 @@ export const addWorkflow = (logger, node, checker, state) => {
     }
     // Track workflow file for wiring generation
     if (exportedName) {
-        state.workflows.files.set(pikkuFuncName, {
+        state.workflows.files.set(pikkuFuncId, {
             path: node.getSourceFile().fileName,
             exportedName,
         });
@@ -261,8 +263,8 @@ export const addWorkflow = (logger, node, checker, state) => {
         getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
     }
     state.workflows.meta[workflowName] = {
-        pikkuFuncName,
-        workflowName,
+        pikkuFuncId,
+        name: workflowName,
         steps,
         context,
         dsl,

package/dist/error-codes.d.ts

@@ -26,9 +26,12 @@ export declare enum ErrorCode {
     SCHEMA_NO_ROOT = "PKU431",
     SCHEMA_GENERATION_ERROR = "PKU456",
     SCHEMA_LOAD_ERROR = "PKU488",
-    INLINE_ZOD_SCHEMA = "PKU489",
+    INLINE_SCHEMA = "PKU489",
     FUNCTION_METADATA_NOT_FOUND = "PKU559",
     HANDLER_NOT_RESOLVED = "PKU568",
+    ROUTE_PARAM_MISMATCH = "PKU571",
+    ROUTE_QUERY_MISMATCH = "PKU572",
+    AUTH_DISABLED_REQUIRES_SESSIONLESS = "PKU573",
     MIDDLEWARE_HANDLER_INVALID = "PKU685",
     MIDDLEWARE_TAG_INVALID = "PKU715",
     MIDDLEWARE_EMPTY_ARRAY = "PKU736",
@@ -37,5 +40,16 @@ export declare enum ErrorCode {
     PERMISSION_TAG_INVALID = "PKU836",
     PERMISSION_EMPTY_ARRAY = "PKU937",
     PERMISSION_PATTERN_INVALID = "PKU975",
+    DUPLICATE_FUNCTION_VERSION = "PKU850",
+    MANIFEST_MISSING = "PKU860",
+    FUNCTION_VERSION_MODIFIED = "PKU861",
+    CONTRACT_CHANGED_REQUIRES_BUMP = "PKU862",
+    VERSION_REGRESSION_OR_CONFLICT = "PKU863",
+    VERSION_GAP_NOT_ALLOWED = "PKU864",
+    MANIFEST_INTEGRITY_ERROR = "PKU865",
+    MISSING_MODEL = "PKU145",
+    INVALID_MODEL = "PKU146",
+    SERVICES_NOT_DESTRUCTURED = "PKU410",
+    WIRES_NOT_DESTRUCTURED = "PKU411",
     WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED = "PKU901"
 }

package/dist/error-codes.js

@@ -29,10 +29,14 @@ export var ErrorCode;
     ErrorCode["SCHEMA_NO_ROOT"] = "PKU431";
     ErrorCode["SCHEMA_GENERATION_ERROR"] = "PKU456";
     ErrorCode["SCHEMA_LOAD_ERROR"] = "PKU488";
-    ErrorCode["INLINE_ZOD_SCHEMA"] = "PKU489";
+    ErrorCode["INLINE_SCHEMA"] = "PKU489";
     // Function errors
     ErrorCode["FUNCTION_METADATA_NOT_FOUND"] = "PKU559";
     ErrorCode["HANDLER_NOT_RESOLVED"] = "PKU568";
+    // HTTP Route errors
+    ErrorCode["ROUTE_PARAM_MISMATCH"] = "PKU571";
+    ErrorCode["ROUTE_QUERY_MISMATCH"] = "PKU572";
+    ErrorCode["AUTH_DISABLED_REQUIRES_SESSIONLESS"] = "PKU573";
     // Middleware/Permission errors
     ErrorCode["MIDDLEWARE_HANDLER_INVALID"] = "PKU685";
     ErrorCode["MIDDLEWARE_TAG_INVALID"] = "PKU715";
@@ -42,6 +46,21 @@ export var ErrorCode;
     ErrorCode["PERMISSION_TAG_INVALID"] = "PKU836";
     ErrorCode["PERMISSION_EMPTY_ARRAY"] = "PKU937";
     ErrorCode["PERMISSION_PATTERN_INVALID"] = "PKU975";
+    // Versioning errors
+    ErrorCode["DUPLICATE_FUNCTION_VERSION"] = "PKU850";
+    // Contract versioning errors
+    ErrorCode["MANIFEST_MISSING"] = "PKU860";
+    ErrorCode["FUNCTION_VERSION_MODIFIED"] = "PKU861";
+    ErrorCode["CONTRACT_CHANGED_REQUIRES_BUMP"] = "PKU862";
+    ErrorCode["VERSION_REGRESSION_OR_CONFLICT"] = "PKU863";
+    ErrorCode["VERSION_GAP_NOT_ALLOWED"] = "PKU864";
+    ErrorCode["MANIFEST_INTEGRITY_ERROR"] = "PKU865";
+    // Model configuration errors
+    ErrorCode["MISSING_MODEL"] = "PKU145";
+    ErrorCode["INVALID_MODEL"] = "PKU146";
+    // Optimization diagnostics
+    ErrorCode["SERVICES_NOT_DESTRUCTURED"] = "PKU410";
+    ErrorCode["WIRES_NOT_DESTRUCTURED"] = "PKU411";
     // Feature Flag
     ErrorCode["WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED"] = "PKU901";
 })(ErrorCode || (ErrorCode = {}));

package/dist/index.d.ts

@@ -1,15 +1,16 @@
 export { inspect, getInitialInspectorState } from './inspector.js';
-export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export type { TypesMap } from './types-map.js';
 export type * from './types.js';
-export type { InspectorState } from './types.js';
-export type { FilesAndMethods, FilesAndMethodsErrors, } from './utils/get-files-and-methods.js';
+export type { FilesAndMethodsErrors } from './utils/get-files-and-methods.js';
 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';
+export { generateCustomTypes, sanitizeTypeName, } from './utils/custom-types-generator.js';
+export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes.js';
+export type { ContractEntry, VersionHashEntry, VersionValidateError, VersionManifest, VersionManifestEntry, } from './utils/contract-hashes.js';
+export { serializeMCPJson } from './utils/serialize-mcp-json.js';
+export type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/index.js';
+export { getFilesAndMethods } from './utils/get-files-and-methods.js';
+export type { SerializedWorkflowGraph, SerializedWorkflowGraphs, } from './utils/workflow/graph/index.js';

package/dist/index.js

@@ -1,8 +1,9 @@
 export { inspect, getInitialInspectorState } from './inspector.js';
-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';
+export { generateCustomTypes, sanitizeTypeName, } from './utils/custom-types-generator.js';
+export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes.js';
+export { serializeMCPJson } from './utils/serialize-mcp-json.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/index.js';
+export { getFilesAndMethods } from './utils/get-files-and-methods.js';

package/dist/inspector.d.ts

@@ -1,8 +1,8 @@
-import { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
+import type { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
 /**
  * Creates an initial/empty inspector state with all required properties initialized
  * @param rootDir - The root directory for the project
  * @returns A fresh InspectorState with empty collections
  */
 export declare function getInitialInspectorState(rootDir: string): InspectorState;
-export declare const inspect: (logger: InspectorLogger, routeFiles: string[], options?: InspectorOptions) => InspectorState;
+export declare const inspect: (logger: InspectorLogger, routeFiles: string[], options?: InspectorOptions) => Promise<InspectorState>;

package/dist/inspector.js

@@ -4,7 +4,14 @@ 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, extractServiceInterfaceMetadata, } from './utils/post-process.js';
+import { aggregateRequiredServices, validateAgentModels, validateAgentOverrides, validateSecretOverrides, validateVariableOverrides, computeResolvedIOTypes, computeMiddlewareGroupsMeta, computePermissionsGroupsMeta, computeRequiredSchemas, computeDiagnostics, } from './utils/post-process.js';
+import { generateOpenAPISpec } from './utils/serialize-openapi-json.js';
+import { pikkuState } from '@pikku/core/internal';
+import { resolveLatestVersions } from './utils/resolve-versions.js';
+import { finalizeWorkflows } from './utils/workflow/graph/finalize-workflows.js';
+import { finalizeWorkflowHelperTypes, finalizeWorkflowWires, } from './utils/workflow/graph/finalize-workflow-wires.js';
+import { generateAllSchemas } from './utils/schema-generator.js';
+import { computeContractHashes, extractContractsFromMeta, updateManifest, createEmptyManifest, validateContracts, } from './utils/contract-hashes.js';
 /**
  * Creates an initial/empty inspector state with all required properties initialized
  * @param rootDir - The root directory for the project
@@ -24,7 +31,8 @@ export function getInitialInspectorState(rootDir) {
         filesAndMethods: {},
         filesAndMethodsErrors: new Map(),
         typesLookup: new Map(),
-        zodLookup: new Map(),
+        schemaLookup: new Map(),
+        schemas: {},
         functions: {
             typesMap: new TypesMap(),
             meta: {},
@@ -49,6 +57,11 @@ export function getInitialInspectorState(rootDir) {
             files: new Set(),
             meta: {},
         },
+        triggers: {
+            meta: {},
+            sourceMeta: {},
+            files: new Set(),
+        },
         scheduledTasks: {
             meta: {},
             files: new Set(),
@@ -62,6 +75,7 @@ export function getInitialInspectorState(rootDir) {
             files: new Map(),
             graphMeta: {},
             graphFiles: new Map(),
+            invokedWorkflows: new Set(),
         },
         rpc: {
             internalMeta: {},
@@ -69,7 +83,9 @@ export function getInitialInspectorState(rootDir) {
             exposedMeta: {},
             exposedFiles: new Map(),
             invokedFunctions: new Set(),
-            usedExternalPackages: new Set(),
+            usedAddons: new Set(),
+            wireAddonDeclarations: new Map(),
+            wireAddonFiles: new Set(),
         },
         mcpEndpoints: {
             resourcesMeta: {},
@@ -77,6 +93,10 @@ export function getInitialInspectorState(rootDir) {
             promptsMeta: {},
             files: new Set(),
         },
+        agents: {
+            agentsMeta: {},
+            files: new Map(),
+        },
         cli: {
             meta: {
                 programs: {},
@@ -84,20 +104,39 @@ export function getInitialInspectorState(rootDir) {
             },
             files: new Set(),
         },
-        forgeNodes: {
+        nodes: {
             meta: {},
             files: new Set(),
         },
-        forgeCredentials: {
-            meta: {},
+        secrets: {
+            definitions: [],
+            files: new Set(),
+        },
+        variables: {
+            definitions: [],
             files: new Set(),
         },
+        manifest: {
+            initial: null,
+            current: null,
+            errors: [],
+        },
         middleware: {
-            meta: {},
+            definitions: {},
+            instances: {},
             tagMiddleware: new Map(),
         },
+        channelMiddleware: {
+            definitions: {},
+            instances: {},
+            tagMiddleware: new Map(),
+        },
+        aiMiddleware: {
+            definitions: {},
+        },
         permissions: {
-            meta: {},
+            definitions: {},
+            instances: {},
             tagPermissions: new Map(),
         },
         serviceAggregation: {
@@ -108,17 +147,36 @@ export function getInitialInspectorState(rootDir) {
             allSingletonServices: [],
             allWireServices: [],
         },
-        serviceMetadata: [],
+        resolvedIOTypes: {},
+        middlewareGroupsMeta: {
+            definitions: {},
+            instances: {},
+            httpGroups: {},
+            tagGroups: {},
+            channelMiddleware: {
+                definitions: {},
+                instances: {},
+                tagGroups: {},
+            },
+        },
+        permissionsGroupsMeta: {
+            definitions: {},
+            httpGroups: {},
+            tagGroups: {},
+        },
+        requiredSchemas: new Set(),
+        openAPISpec: null,
+        diagnostics: [],
     };
 }
-export const inspect = (logger, routeFiles, options = {}) => {
+export const inspect = async (logger, routeFiles, options = {}) => {
     const startProgram = performance.now();
     const program = ts.createProgram(routeFiles, {
         target: ts.ScriptTarget.ESNext,
-        module: ts.ModuleKind.CommonJS,
+        module: ts.ModuleKind.Node16,
         skipLibCheck: true,
         skipDefaultLibCheck: true,
-        moduleResolution: ts.ModuleResolutionKind.Node10,
+        moduleResolution: ts.ModuleResolutionKind.Node16,
         types: [],
         allowJs: false,
         checkJs: false,
@@ -150,6 +208,20 @@ export const inspect = (logger, routeFiles, options = {}) => {
             ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, options));
         }
         logger.debug(`Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(2)}ms`);
+        resolveLatestVersions(state, logger);
+        if (options.schemaConfig) {
+            state.schemas = await generateAllSchemas(logger, options.schemaConfig, state);
+            computeContractHashes(state.schemas, state.functions.typesMap, state.functions.meta);
+            computeRequiredSchemas(state, options);
+        }
+        state.manifest.initial = options.manifest ?? null;
+        const contracts = extractContractsFromMeta(state.functions.meta);
+        const baseManifest = state.manifest.initial ?? createEmptyManifest();
+        state.manifest.current = updateManifest(baseManifest, contracts);
+        state.manifest.errors = validateContracts(baseManifest, contracts).errors;
+        finalizeWorkflows(state);
+        finalizeWorkflowHelperTypes(state);
+        finalizeWorkflowWires(state);
     }
     // Populate filesAndMethods
     const startFilesAndMethods = performance.now();
@@ -161,9 +233,17 @@ 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`);
+        computeResolvedIOTypes(state);
+        computeMiddlewareGroupsMeta(state);
+        computePermissionsGroupsMeta(state);
+        computeDiagnostics(state);
+        if (options.openAPI) {
+            state.openAPISpec = await generateOpenAPISpec(logger, state.functions.meta, state.http.meta, state.schemas, options.openAPI.additionalInfo, pikkuState(null, 'misc', 'errors'));
+        }
+        validateAgentModels(logger, state, options.modelConfig);
+        validateAgentOverrides(logger, state, options.modelConfig);
+        validateSecretOverrides(logger, state);
+        validateVariableOverrides(logger, state);
     }
     return state;
 };

package/dist/schema-generator.d.ts

@@ -0,0 +1 @@
+export { generateAllSchemas } from './utils/schema-generator.js';

package/dist/schema-generator.js

@@ -0,0 +1 @@
+export { generateAllSchemas } from './utils/schema-generator.js';

package/dist/types-map.js

@@ -17,7 +17,16 @@ export class TypesMap {
         return meta.uniqueName;
     }
     getTypeMeta(name) {
-        if (['string', 'number', 'boolean', 'null'].includes(name)) {
+        if ([
+            'string',
+            'number',
+            'boolean',
+            'null',
+            'undefined',
+            'void',
+            'unknown',
+            'never',
+        ].includes(name)) {
             return {
                 originalName: name,
                 uniqueName: name,