@pikku/inspector 0.11.2 → 0.12.1

package/dist/types.d.ts

@@ -1,15 +1,21 @@
-import * as ts from 'typescript';
-import { ChannelsMeta } from '@pikku/core/channel';
-import { HTTPWiringsMeta } from '@pikku/core/http';
-import { ScheduledTasksMeta } from '@pikku/core/scheduler';
-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 * as ts from 'typescript';
+import type { ChannelsMeta } from '@pikku/core/channel';
+import type { HTTPWiringsMeta } from '@pikku/core/http';
+import type { ScheduledTasksMeta } from '@pikku/core/scheduler';
+import type { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger';
+import type { QueueWorkersMeta } from '@pikku/core/queue';
+import type { WorkflowsMeta } from '@pikku/core/workflow';
+import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
+import type { AIAgentMeta } from '@pikku/core/ai-agent';
+import type { CLIMeta } from '@pikku/core/cli';
+import type { NodesMeta } from '@pikku/core/node';
+import type { SecretDefinitions } from '@pikku/core/secret';
+import type { VariableDefinitions } from '@pikku/core/variable';
+import type { TypesMap } from './types-map.js';
+import type { FunctionsMeta, FunctionServicesMeta, FunctionWiresMeta, JSONValue } from '@pikku/core';
+import type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js';
+import type { ErrorCode } from './error-codes.js';
+import type { VersionManifest, VersionValidateError } from './utils/contract-hashes.js';
 import type { SerializedWorkflowGraphs } from './utils/workflow/graph/workflow-graph.types.js';
 export type PathToNameAndType = Map<string, {
     variable: string;
@@ -26,7 +32,8 @@ export interface MiddlewareGroupMeta {
     sourceFile: string;
     position: number;
     services: FunctionServicesMeta;
-    middlewareCount: number;
+    count: number;
+    instanceIds: string[];
     isFactory: boolean;
 }
 export interface PermissionGroupMeta {
@@ -34,7 +41,8 @@ export interface PermissionGroupMeta {
     sourceFile: string;
     position: number;
     services: FunctionServicesMeta;
-    permissionCount: number;
+    count: number;
+    instanceIds: string[];
     isFactory: boolean;
 }
 export interface InspectorHTTPState {
@@ -45,11 +53,17 @@ export interface InspectorHTTPState {
     routePermissions: Map<string, PermissionGroupMeta>;
 }
 /**
- * Zod schema reference for deferred conversion to JSON Schema at build time
+ * Schema vendor types for Standard Schema compliant validators
  */
-export interface ZodSchemaRef {
+export type SchemaVendor = 'zod' | 'valibot' | 'arktype' | 'effect' | 'unknown';
+/**
+ * Schema reference for deferred conversion to JSON Schema at build time.
+ * Supports Standard Schema compliant validators (Zod, Valibot, ArkType, Effect Schema).
+ */
+export interface SchemaRef {
     variableName: string;
     sourceFile: string;
+    vendor?: SchemaVendor;
 }
 export interface InspectorFunctionState {
     typesMap: TypesMap;
@@ -63,28 +77,57 @@ export interface InspectorChannelState {
     meta: ChannelsMeta;
     files: Set<string>;
 }
+export interface InspectorMiddlewareDefinition {
+    services: FunctionServicesMeta;
+    wires?: FunctionWiresMeta;
+    sourceFile: string;
+    position: number;
+    exportedName: string | null;
+    factory?: boolean;
+    name?: string;
+    description?: string;
+    package?: string;
+}
+export interface InspectorMiddlewareInstance {
+    definitionId: string;
+    sourceFile: string;
+    position: number;
+    isFactoryCall: boolean;
+}
 export interface InspectorMiddlewareState {
-    meta: Record<string, {
-        services: FunctionServicesMeta;
-        sourceFile: string;
-        position: number;
-        exportedName: string | null;
-        factory?: boolean;
-        name?: string;
-        description?: string;
-    }>;
+    definitions: Record<string, InspectorMiddlewareDefinition>;
+    instances: Record<string, InspectorMiddlewareInstance>;
+    tagMiddleware: Map<string, MiddlewareGroupMeta>;
+}
+export interface InspectorChannelMiddlewareState {
+    definitions: Record<string, InspectorMiddlewareDefinition>;
+    instances: Record<string, InspectorMiddlewareInstance>;
     tagMiddleware: Map<string, MiddlewareGroupMeta>;
 }
+export interface InspectorAIMiddlewareState {
+    definitions: Record<string, InspectorMiddlewareDefinition>;
+}
+export interface InspectorPermissionDefinition {
+    services: FunctionServicesMeta;
+    wires?: FunctionWiresMeta;
+    sourceFile: string;
+    position: number;
+    exportedName: string | null;
+    factory?: boolean;
+    name?: string;
+    description?: string;
+    package?: string;
+    requiresData?: boolean;
+}
+export interface InspectorPermissionInstance {
+    definitionId: string;
+    sourceFile: string;
+    position: number;
+    isFactoryCall: boolean;
+}
 export interface InspectorPermissionState {
-    meta: Record<string, {
-        services: FunctionServicesMeta;
-        sourceFile: string;
-        position: number;
-        exportedName: string | null;
-        factory?: boolean;
-        name?: string;
-        description?: string;
-    }>;
+    definitions: Record<string, InspectorPermissionDefinition>;
+    instances: Record<string, InspectorPermissionInstance>;
     tagPermissions: Map<string, PermissionGroupMeta>;
 }
 export type InspectorFilters = {
@@ -95,16 +138,52 @@ export type InspectorFilters = {
     httpRoutes?: string[];
     httpMethods?: string[];
 };
+export type AddonConfig = {
+    package: string;
+    rpcEndpoint?: string;
+    secretOverrides?: Record<string, string>;
+    forceInclude?: boolean;
+};
+export type ModelConfigEntry = string | {
+    model: string;
+    temperature?: number;
+    maxSteps?: number;
+};
+export type InspectorModelConfig = {
+    models?: Record<string, ModelConfigEntry>;
+    agentDefaults?: {
+        temperature?: number;
+        maxSteps?: number;
+    };
+    agentOverrides?: Record<string, {
+        model?: string;
+        temperature?: number;
+        maxSteps?: number;
+    }>;
+};
 export type InspectorOptions = Partial<{
     setupOnly: boolean;
-    /** Project root directory - used to filter out external package files */
     rootDir: string;
+    isAddon: boolean;
     types: Partial<{
         configFileType: string;
         userSessionType: string;
         singletonServicesFactoryType: string;
         wireServicesFactoryType: string;
     }>;
+    schemaConfig: {
+        tsconfig: string;
+        schemasFromTypes?: string[];
+        schema?: {
+            additionalProperties?: boolean;
+        };
+    };
+    openAPI: {
+        additionalInfo: OpenAPISpecInfo;
+    };
+    tags: string[];
+    manifest: VersionManifest;
+    modelConfig: InspectorModelConfig;
 }>;
 export interface InspectorLogger {
     info: (message: string) => void;
@@ -159,6 +238,12 @@ export interface InspectorFilesAndMethods {
         typePath: string;
     };
 }
+export interface InspectorDiagnostic {
+    code: string;
+    message: string;
+    sourceFile: string;
+    position: number;
+}
 export interface InspectorState {
     rootDir: string;
     singletonServicesTypeImportMap: PathToNameAndType;
@@ -172,10 +257,16 @@ export interface InspectorState {
     filesAndMethods: InspectorFilesAndMethods;
     filesAndMethodsErrors: Map<string, PathToNameAndType>;
     typesLookup: Map<string, ts.Type[]>;
-    zodLookup: Map<string, ZodSchemaRef>;
+    schemaLookup: Map<string, SchemaRef>;
+    schemas: Record<string, JSONValue>;
     http: InspectorHTTPState;
     functions: InspectorFunctionState;
     channels: InspectorChannelState;
+    triggers: {
+        meta: TriggerMeta;
+        sourceMeta: TriggerSourceMeta;
+        files: Set<string>;
+    };
     scheduledTasks: {
         meta: ScheduledTasksMeta;
         files: Set<string>;
@@ -195,6 +286,7 @@ export interface InspectorState {
             path: string;
             exportedName: string;
         }>;
+        invokedWorkflows: Set<string>;
     };
     rpc: {
         internalMeta: Record<string, string>;
@@ -208,7 +300,14 @@ export interface InspectorState {
             exportedName: string;
         }>;
         invokedFunctions: Set<string>;
-        usedExternalPackages: Set<string>;
+        usedAddons: Set<string>;
+        wireAddonDeclarations: Map<string, {
+            package: string;
+            rpcEndpoint?: string;
+            secretOverrides?: Record<string, string>;
+            variableOverrides?: Record<string, string>;
+        }>;
+        wireAddonFiles: Set<string>;
     };
     mcpEndpoints: {
         resourcesMeta: MCPResourceMeta;
@@ -216,19 +315,37 @@ export interface InspectorState {
         promptsMeta: MCPPromptMeta;
         files: Set<string>;
     };
+    agents: {
+        agentsMeta: AIAgentMeta;
+        files: Map<string, {
+            path: string;
+            exportedName: string;
+        }>;
+    };
     cli: {
         meta: CLIMeta;
         files: Set<string>;
     };
-    forgeNodes: {
-        meta: ForgeNodesMeta;
+    nodes: {
+        meta: NodesMeta;
         files: Set<string>;
     };
-    forgeCredentials: {
-        meta: ForgeCredentialsMeta;
+    secrets: {
+        definitions: SecretDefinitions;
         files: Set<string>;
     };
+    variables: {
+        definitions: VariableDefinitions;
+        files: Set<string>;
+    };
+    manifest: {
+        initial: VersionManifest | null;
+        current: VersionManifest | null;
+        errors: VersionValidateError[];
+    };
     middleware: InspectorMiddlewareState;
+    channelMiddleware: InspectorChannelMiddlewareState;
+    aiMiddleware: InspectorAIMiddlewareState;
     permissions: InspectorPermissionState;
     serviceAggregation: {
         requiredServices: Set<string>;
@@ -238,14 +355,27 @@ export interface InspectorState {
         allSingletonServices: string[];
         allWireServices: string[];
     };
-    serviceMetadata: Array<{
-        name: string;
-        summary: string;
-        description: string;
-        package: string;
-        path: string;
-        version: string;
-        interface: string;
-        expandedProperties: Record<string, string>;
+    resolvedIOTypes: Record<string, {
+        inputType: string;
+        outputType: string;
     }>;
+    middlewareGroupsMeta: {
+        definitions: Record<string, InspectorMiddlewareDefinition>;
+        instances: Record<string, InspectorMiddlewareInstance>;
+        httpGroups: Record<string, MiddlewareGroupMeta>;
+        tagGroups: Record<string, MiddlewareGroupMeta>;
+        channelMiddleware: {
+            definitions: Record<string, InspectorMiddlewareDefinition>;
+            instances: Record<string, InspectorMiddlewareInstance>;
+            tagGroups: Record<string, MiddlewareGroupMeta>;
+        };
+    };
+    permissionsGroupsMeta: {
+        definitions: Record<string, InspectorPermissionDefinition>;
+        httpGroups: Record<string, PermissionGroupMeta>;
+        tagGroups: Record<string, PermissionGroupMeta>;
+    };
+    requiredSchemas: Set<string>;
+    openAPISpec: Record<string, any> | null;
+    diagnostics: InspectorDiagnostic[];
 }

package/dist/utils/compute-required-schemas.d.ts

@@ -0,0 +1,4 @@
+import type { FunctionsMeta } from '@pikku/core';
+import type { TypesMap } from '../types-map.js';
+import type { SchemaRef } from '../types.js';
+export declare function computeRequiredSchemas(functionsMeta: FunctionsMeta, typesMap: TypesMap, additionalTypes?: string[], schemaLookup?: Map<string, SchemaRef>): Set<string>;

package/dist/utils/compute-required-schemas.js

@@ -0,0 +1,40 @@
+const PRIMITIVE_TYPES = new Set([
+    'boolean',
+    'string',
+    'number',
+    'null',
+    'undefined',
+    'void',
+    'any',
+    'unknown',
+    'never',
+]);
+export function computeRequiredSchemas(functionsMeta, typesMap, additionalTypes, schemaLookup) {
+    return new Set([
+        ...Object.values(functionsMeta)
+            .flatMap(({ inputs, outputs }) => {
+            const types = [];
+            if (inputs?.[0]) {
+                try {
+                    types.push(typesMap.getUniqueName(inputs[0]));
+                }
+                catch {
+                    types.push(inputs[0]);
+                }
+            }
+            if (outputs?.[0]) {
+                try {
+                    types.push(typesMap.getUniqueName(outputs[0]));
+                }
+                catch {
+                    types.push(outputs[0]);
+                }
+            }
+            return types;
+        })
+            .filter((s) => !!s && !PRIMITIVE_TYPES.has(s)),
+        ...typesMap.customTypes.keys(),
+        ...(additionalTypes || []),
+        ...(schemaLookup ? Array.from(schemaLookup.keys()) : []),
+    ]);
+}

package/dist/utils/contract-hashes.d.ts

@@ -0,0 +1,52 @@
+import type { FunctionsMeta, JSONValue } from '@pikku/core';
+import type { TypesMap } from '../types-map.js';
+import { ErrorCode } from '../error-codes.js';
+export type ContractEntry = {
+    functionKey: string;
+    version: number;
+    contractHash: string;
+    inputHash: string;
+    outputHash: string;
+};
+export type VersionValidateError = {
+    code: ErrorCode;
+    message: string;
+    functionKey?: string;
+    version?: number;
+    previousHash?: string;
+    currentHash?: string;
+    previousInputHash?: string;
+    currentInputHash?: string;
+    previousOutputHash?: string;
+    currentOutputHash?: string;
+    nextVersion?: number;
+    latestVersion?: number;
+    expectedNextVersion?: number;
+};
+export type VersionHashEntry = {
+    inputHash: string;
+    outputHash: string;
+};
+export type VersionManifestEntry = {
+    latest: number;
+    versions: Record<string, string | VersionHashEntry>;
+};
+export type VersionManifest = {
+    manifestVersion: 1;
+    contracts: Record<string, VersionManifestEntry>;
+};
+export declare function createEmptyManifest(): VersionManifest;
+export declare function serializeManifest(manifest: VersionManifest): string;
+export declare function computeContractHash(data: {
+    functionKey: string;
+    inputSchema: unknown;
+    outputSchema: unknown;
+}): string;
+export declare function buildCurrentContracts(functionsMeta: FunctionsMeta, allSchemas: Record<string, JSONValue>, typesMap: TypesMap): Map<string, ContractEntry>;
+export declare function computeContractHashes(allSchemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta): Map<string, ContractEntry>;
+export declare function validateContracts(manifest: VersionManifest, currentContracts: Map<string, ContractEntry>): {
+    valid: boolean;
+    errors: VersionValidateError[];
+};
+export declare function updateManifest(existing: VersionManifest, currentContracts: Map<string, ContractEntry>): VersionManifest;
+export declare function extractContractsFromMeta(functionsMeta: FunctionsMeta): Map<string, ContractEntry>;