@pikku/inspector 0.12.10 → 0.12.12

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 0.12.12
+
+### Patch Changes
+
+- 9060165: Agents now declare their model directly as `<provider>/<model>` (e.g. `openai/gpt-4o`). The `models`, `agentDefaults`, and `agentOverrides` config blocks have been removed.
+
+  **Migration:** replace any bare `model: 'alias'` values with the full provider-qualified form and remove those blocks from `pikku.config.json`.
+
+- Updated dependencies [9060165]
+- Updated dependencies [9060165]
+- Updated dependencies [9060165]
+  - @pikku/core@0.12.21
+
+## 0.12.11
+
+### Patch Changes
+
+- 033d172: Log a critical inspector error when multiple functions resolve to the same `pikku` function name, instead of silently allowing routing map collisions. This may cause builds to fail if multiple functions previously resolved to the same `pikku` function name.
+- Updated dependencies [b9ed73e]
+  - @pikku/core@0.12.19
+
 ## 0.12.0
 
 ## 0.12.10
@@ -32,7 +53,6 @@
 ### Patch Changes
 
 - 624097e: Add deploy pipeline with provider-agnostic architecture
-
   - Add MetaService with explicit typed API, absorb WiringService reads
   - Add deployment service, traceId propagation, scoped logger
   - Rewrite analyzer: one function = one worker, gateways dispatch via RPC
@@ -79,7 +99,6 @@
 
 - 5866b66: Add critical error (PKU490) when Zod schemas and wiring calls (wireHTTPRoutes, addPermission, addHTTPMiddleware) coexist in the same file. The CLI uses tsImport to extract Zod schemas at runtime, which executes all top-level code — wiring side-effects crash in this context because pikku state metadata doesn't exist. Schemas and wirings must be in separate files.
 - e412b4d: Optimize CLI codegen performance: 12x faster `pikku all`
-
   - Reuse schemas across re-inspections (skip redundant `ts-json-schema-generator` runs)
   - Cache TS schemas to disk (`.pikku/schema-cache.json`) for cross-run reuse
   - Pass `oldProgram` to `ts.createProgram` for incremental TS compilation
@@ -208,14 +227,12 @@
 - 1967172: Update code generation to support channel middleware enhancements
 
   **Code Generation Updates:**
-
   - Update channel type serialization to include middleware support
   - Improve WebSocket wrapper generation for middleware handling
   - Update CLI channel client generation with better type support
   - Enhance services and schema generation for channel configurations
 
   **Inspector Updates:**
-
   - Improve channel metadata extraction for middleware
   - Better type analysis for channel lifecycle functions
   - Enhanced post-processing for channel configurations
@@ -223,19 +240,16 @@
 - 753481a: Add bootstrap command, performance optimizations, and CLI improvements
 
   **New Features:**
-
   - Add `pikku bootstrap` command for type-only generation (~13.5% faster than `pikku all`)
   - Add configurable `ignoreFiles` option to pikku.config.json with sensible defaults (_.gen.ts, _.test.ts, \*.spec.ts)
   - Export pikkuCLIRender helper from serialize-cli-types.ts with JSDoc documentation
 
   **Performance Improvements:**
-
   - Add aggressive TypeScript compiler options (skipDefaultLibCheck, types: []) - ~37% faster TypeScript setup
   - Add detailed performance timing to inspector phases (--logLevel=debug)
   - Optimize file inspection with ignore patterns - ~10-20% faster overall
 
   **Enhancements:**
-
   - Fix --logLevel flag to properly apply log level to logger
   - Update middleware logging to use structured log format
   - Improve CLI renderers to consistently use destructured logger service
@@ -336,7 +350,6 @@ For complete details, see https://pikku.dev/changelogs/0_10_0.md
 ### Patch Changes
 
 - 44e3ff4: feat: enhance CLI filtering with type and directory filters
-
   - Add --types filter to filter by PikkuEventTypes (http, channel, queue, scheduler, rpc, mcp)
   - Add --directories filter to filter by file paths/directories
   - All filters (tags, types, directories) now work together with AND logic
@@ -347,7 +360,6 @@ For complete details, see https://pikku.dev/changelogs/0_10_0.md
 - 7c592b8: feat: support for required services and improved service configuration
 
   This release includes several enhancements to service management and configuration:
-
   - Added support for required services configuration
   - Improved service discovery and registration
   - Added typed RPC clients for service communication

package/dist/add/add-cli.js

@@ -295,10 +295,16 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                     meta.options = processOptions(logger, optionsNode, typeChecker, inspectorState, options, pikkuFuncId);
                 }
                 break;
-            case 'subcommands':
-                if (ts.isObjectLiteralExpression(prop.initializer)) {
+            case 'subcommands': {
+                let subcommandsNode = prop.initializer;
+                if (ts.isIdentifier(prop.initializer)) {
+                    subcommandsNode = resolveIdentifier(prop.initializer, typeChecker, [
+                        'defineCLICommands',
+                    ]);
+                }
+                if (subcommandsNode && ts.isObjectLiteralExpression(subcommandsNode)) {
                     meta.subcommands = {};
-                    for (const subProp of prop.initializer.properties) {
+                    for (const subProp of subcommandsNode.properties) {
                         if (!ts.isPropertyAssignment(subProp))
                             continue;
                         const subName = getPropertyName(subProp);
@@ -311,6 +317,7 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                     }
                 }
                 break;
+            }
             case 'isDefault':
                 if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
                     prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {

package/dist/add/add-credential.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getArrayPropertyValue, } from '../utils/get-property-value.js';
+import { getPropertyValue, getArrayPropertyValue, assertStringLiteralProperty, } from '../utils/get-property-value.js';
 import { ErrorCode } from '../error-codes.js';
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
 export const addCredential = (logger, node, checker, state, _options) => {
@@ -17,6 +17,7 @@ export const addCredential = (logger, node, checker, state, _options) => {
     }
     if (ts.isObjectLiteralExpression(firstArg)) {
         const obj = firstArg;
+        assertStringLiteralProperty(obj, 'name', 'Credential', logger);
         const nameValue = getPropertyValue(obj, 'name');
         const displayNameValue = getPropertyValue(obj, 'displayName');
         const descriptionValue = getPropertyValue(obj, 'description');

package/dist/add/add-functions.js

@@ -3,8 +3,9 @@ import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
 import { extractFunctionName, funcIdToTypeName, } from '../utils/extract-function-name.js';
 import { extractFunctionNode } from '../utils/extract-function-node.js';
 import { extractUsedWires } from '../utils/extract-services.js';
-import { formatVersionedId } from '@pikku/core';
+import { formatVersionedId, parseVersionedId } from '@pikku/core';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
+import { canonicalJSON, hashString } from '../utils/hash.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { resolvePermissions } from '../utils/permissions.js';
 import { extractWireNames } from '../utils/post-process.js';
@@ -209,6 +210,33 @@ function unwrapPromise(checker, type) {
     }
     return type;
 }
+const resolveExistingFunctionSource = (state, pikkuFuncId) => {
+    return (state.functions.meta[pikkuFuncId]?.sourceFile ||
+        state.rpc.internalFiles.get(pikkuFuncId)?.path ||
+        null);
+};
+const areCompatibleFunctionIds = (existingId, incomingId) => {
+    if (existingId === incomingId) {
+        return true;
+    }
+    const existingParsed = parseVersionedId(existingId);
+    const incomingParsed = parseVersionedId(incomingId);
+    return existingParsed.baseName === incomingParsed.baseName;
+};
+function printNode(node) {
+    return ts
+        .createPrinter({ removeComments: true })
+        .printNode(ts.EmitHint.Unspecified, node, node.getSourceFile());
+}
+function computeImplementationHash(args) {
+    const { wrapper, handler, objectNode, isDirectFunction } = args;
+    return hashString(canonicalJSON({
+        wrapper,
+        isDirectFunction,
+        handler: printNode(handler),
+        config: objectNode ? printNode(objectNode) : null,
+    }));
+}
 /**
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
@@ -396,10 +424,16 @@ export const addFunctions = (logger, node, checker, state, options) => {
         }
     }
     if (version !== undefined) {
-        const baseName = explicitName || exportedName || pikkuFuncId;
+        let baseName = explicitName || exportedName || pikkuFuncId;
+        // Strip trailing VN suffix if it matches the version (e.g. getDataV1 + version:1 → getData@v1)
+        const vSuffix = `V${version}`;
+        if (baseName.endsWith(vSuffix) && baseName.length > vSuffix.length) {
+            baseName = baseName.slice(0, -vSuffix.length);
+        }
         pikkuFuncId = formatVersionedId(baseName, version);
     }
     const isMCPToolFunc = expression.text === 'pikkuMCPToolFunc';
+    const isListFunc = expression.text === 'pikkuListFunc';
     const mcpEnabled = mcp || isMCPToolFunc;
     // Pick the handler: use resolvedFunc when it exists and is a function, otherwise fall back to handlerNode
     const handler = resolvedFunc &&
@@ -461,7 +495,22 @@ export const addFunctions = (logger, node, checker, state, options) => {
         state.schemaLookup.set(schemaName, inputSchemaRef);
         state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
     }
-    else if (genericTypes.length >= 1 && genericTypes[0]) {
+    else if (isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
+        const inputAliasName = `${capitalizedName}Input`;
+        const filterType = genericTypes[0];
+        const filterTypeText = checker.typeToString(filterType, undefined, ts.TypeFormatFlags.NoTruncation);
+        const refs = resolveTypeImports(filterType, state.functions.typesMap, true, checker);
+        state.functions.typesMap.addCustomType(inputAliasName, `{ cursor?: string; limit?: number; sort?: Array<{ column: string; direction: 'asc' | 'desc' }>; filter?: unknown; search?: string; } & ${filterTypeText}`, [...new Set(refs)]);
+        inputNames = [inputAliasName];
+        const secondParam = handler.parameters[1];
+        if (secondParam) {
+            inputTypes = [checker.getTypeAtLocation(secondParam)];
+        }
+        else {
+            inputTypes = [filterType];
+        }
+    }
+    else if (!isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
         // Fall back to extracting from generic type arguments
         const result = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
         inputNames = result.names;
@@ -485,7 +534,15 @@ export const addFunctions = (logger, node, checker, state, options) => {
         state.schemaLookup.set(schemaName, outputSchemaRef);
         state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
     }
-    else if (genericTypes.length >= 2) {
+    else if (isListFunc && genericTypes.length >= 2 && genericTypes[1]) {
+        const outputAliasName = `${capitalizedName}Output`;
+        const rowType = genericTypes[1];
+        const rowTypeText = checker.typeToString(rowType, undefined, ts.TypeFormatFlags.NoTruncation);
+        const refs = resolveTypeImports(rowType, state.functions.typesMap, true, checker);
+        state.functions.typesMap.addCustomType(outputAliasName, `{ rows: Array<${rowTypeText}>; nextCursor: string | null; totalCount?: number; }`, [...new Set(refs)]);
+        outputNames = [outputAliasName];
+    }
+    else if (!isListFunc && genericTypes.length >= 2) {
         outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', name, genericTypes[1]).names;
     }
     else {
@@ -539,6 +596,36 @@ export const addFunctions = (logger, node, checker, state, options) => {
     if (inputTypes.length > 0) {
         state.typesLookup.set(pikkuFuncId, inputTypes);
     }
+    const sourceFile = node.getSourceFile().fileName;
+    const existingFunction = state.functions.meta[pikkuFuncId];
+    if (existingFunction &&
+        existingFunction.sourceFile &&
+        existingFunction.sourceFile !== sourceFile) {
+        logger.critical(ErrorCode.DUPLICATE_FUNCTION_NAME, `Function name '${name}' is not unique. ` +
+            `'${pikkuFuncId}' is already defined in '${existingFunction.sourceFile}' and cannot be redefined in '${sourceFile}'.`);
+        return;
+    }
+    if (exportedName || explicitName) {
+        const existingInternal = state.rpc.internalMeta[name];
+        if (existingInternal &&
+            !areCompatibleFunctionIds(existingInternal, pikkuFuncId)) {
+            const existingSource = resolveExistingFunctionSource(state, existingInternal) || 'unknown file';
+            logger.critical(ErrorCode.DUPLICATE_FUNCTION_NAME, `Function name '${name}' is not unique. ` +
+                `It already points to '${existingInternal}' in '${existingSource}', but '${pikkuFuncId}' in '${sourceFile}' tried to use the same name.`);
+            return;
+        }
+        if (expose) {
+            const existingExposed = state.rpc.exposedMeta[name];
+            if (existingExposed &&
+                !areCompatibleFunctionIds(existingExposed, pikkuFuncId)) {
+                const existingSource = resolveExistingFunctionSource(state, existingExposed) ||
+                    'unknown file';
+                logger.critical(ErrorCode.DUPLICATE_FUNCTION_NAME, `Exposed function name '${name}' is not unique. ` +
+                    `It already points to '${existingExposed}' in '${existingSource}', but '${pikkuFuncId}' in '${sourceFile}' tried to use the same name.`);
+                return;
+            }
+        }
+    }
     // --- resolve middleware ---
     let middleware = objectNode
         ? resolveMiddleware(state, objectNode, tags, checker)
@@ -569,6 +656,12 @@ export const addFunctions = (logger, node, checker, state, options) => {
         }
     }
     const sessionless = expression.text !== 'pikkuFunc';
+    const implementationHash = computeImplementationHash({
+        wrapper: expression.text,
+        handler,
+        objectNode,
+        isDirectFunction,
+    });
     state.functions.meta[pikkuFuncId] = {
         pikkuFuncId,
         functionType: 'user',
@@ -588,6 +681,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         deploy: deploy || undefined,
         approvalRequired: approvalRequired || undefined,
         approvalDescription: approvalDescription || undefined,
+        implementationHash,
         version,
         title,
         tags: tags || undefined,
@@ -597,7 +691,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         middleware,
         permissions,
         isDirectFunction,
-        sourceFile: node.getSourceFile().fileName,
+        sourceFile,
         exportedName: exportedName || undefined,
     };
     // Populate node metadata if node config is present

package/dist/add/add-http-route.js

@@ -7,6 +7,7 @@ import { resolveHTTPMiddlewareFromObject } from '../utils/middleware.js';
 import { resolveHTTPPermissionsFromObject } from '../utils/permissions.js';
 import { extractWireNames } from '../utils/post-process.js';
 import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js';
+import { resolveFunctionMeta } from '../utils/resolve-function-meta.js';
 import { ErrorCode } from '../error-codes.js';
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
@@ -113,12 +114,30 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     if (funcName.startsWith('__temp_')) {
         funcName = makeContextBasedId('http', method, fullRoute);
     }
+    let refAddonTarget = null;
+    if (ts.isCallExpression(funcInitializer) &&
+        ts.isIdentifier(funcInitializer.expression) &&
+        funcInitializer.expression.text === 'ref') {
+        const [firstArg] = funcInitializer.arguments;
+        if (firstArg &&
+            ts.isStringLiteral(firstArg) &&
+            firstArg.text.includes(':')) {
+            refAddonTarget = firstArg.text;
+        }
+    }
     const packageName = ts.isIdentifier(funcInitializer)
         ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
         : null;
+    if (refAddonTarget) {
+        const targetMeta = resolveFunctionMeta(state, refAddonTarget);
+        if (!targetMeta) {
+            logger.warn(`Skipping route '${fullRoute}': addon function metadata for '${refAddonTarget}' is not available yet.`);
+            return;
+        }
+    }
     ensureFunctionMetadata(state, funcName, fullRoute, funcInitializer, checker, extracted.isHelper);
     // Lookup existing function metadata
-    const fnMeta = state.functions.meta[funcName];
+    const fnMeta = resolveFunctionMeta(state, funcName);
     if (!fnMeta) {
         logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${funcName}'.`);
         return;
@@ -127,17 +146,36 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
         return;
     }
     const input = fnMeta.inputs?.[0] || null;
+    const getRouteInputKeys = () => {
+        const targetFuncName = refAddonTarget ?? funcName;
+        const inputTypes = state.typesLookup.get(targetFuncName);
+        if (inputTypes && inputTypes.length > 0) {
+            return extractTypeKeys(inputTypes[0]);
+        }
+        const targetMeta = resolveFunctionMeta(state, targetFuncName);
+        if (targetMeta?.inputSchemaName) {
+            const schema = state.schemas[targetMeta.inputSchemaName];
+            const properties = schema?.properties;
+            if (properties && typeof properties === 'object') {
+                return Object.keys(properties);
+            }
+        }
+        return null;
+    };
     // Validate that route params and query params exist in function input type
     if (params.length > 0 || query.length > 0) {
-        const inputTypes = state.typesLookup.get(funcName);
-        if (inputTypes && inputTypes.length > 0) {
-            const inputKeys = extractTypeKeys(inputTypes[0]);
+        const inputKeys = getRouteInputKeys();
+        if (!inputKeys) {
+            // Input shape isn't inspectable at this phase (e.g. addon ref or opaque handler).
+            // Skip param/query validation rather than emitting a false positive.
+        }
+        else {
             // Check path params
             if (params.length > 0) {
                 const missingParams = params.filter((p) => !inputKeys.includes(p));
                 if (missingParams.length > 0) {
                     logger.critical(ErrorCode.ROUTE_PARAM_MISMATCH, `Route '${fullRoute}' has path parameter(s) [${missingParams.join(', ')}] ` +
-                        `not found in function '${funcName}' input type. ` +
+                        `not found in function '${refAddonTarget ?? funcName}' input type. ` +
                         `Input type has: [${inputKeys.join(', ')}]`);
                     return;
                 }
@@ -147,7 +185,7 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
                 const missingQuery = query.filter((q) => !inputKeys.includes(q));
                 if (missingQuery.length > 0) {
                     logger.critical(ErrorCode.ROUTE_QUERY_MISMATCH, `Route '${fullRoute}' has query parameter(s) [${missingQuery.join(', ')}] ` +
-                        `not found in function '${funcName}' input type. ` +
+                        `not found in function '${refAddonTarget ?? funcName}' input type. ` +
                         `Input type has: [${inputKeys.join(', ')}]`);
                     return;
                 }

package/dist/add/add-keyed-wiring.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
+import { getPropertyValue, assertStringLiteralProperty, } from '../utils/get-property-value.js';
 import { ErrorCode } from '../error-codes.js';
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
 export const createAddKeyedWiring = (config) => {
@@ -19,6 +19,8 @@ export const createAddKeyedWiring = (config) => {
         }
         if (ts.isObjectLiteralExpression(firstArg)) {
             const obj = firstArg;
+            assertStringLiteralProperty(obj, 'name', config.label, logger);
+            assertStringLiteralProperty(obj, config.idField, config.label, logger);
             const nameValue = getPropertyValue(obj, 'name');
             const displayNameValue = getPropertyValue(obj, 'displayName');
             const descriptionValue = getPropertyValue(obj, 'description');

package/dist/add/add-middleware.js

@@ -171,7 +171,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found middleware factory with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
-    if (expression.text === 'addMiddleware') {
+    if (expression.text === 'addTagMiddleware') {
         const tagArg = args[0];
         const middlewareArrayArg = args[1];
         if (!tagArg || !middlewareArrayArg)
@@ -181,11 +181,11 @@ export const addMiddleware = (logger, node, checker, state) => {
             tag = tagArg.text;
         }
         if (!tag) {
-            logger.warn(`• addMiddleware call without valid tag string`);
+            logger.warn(`• addTagMiddleware call without valid tag string`);
             return;
         }
         if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
-            logger.error(`• addMiddleware('${tag}', ...) must have a literal array as second argument`);
+            logger.error(`• addTagMiddleware('${tag}', ...) must have a literal array as second argument`);
             return;
         }
         const refs = extractMiddlewareRefs(middlewareArrayArg, checker, state.rootDir);
@@ -236,7 +236,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         }
         if (!isFactory && exportedName) {
             logger.warn(`• Middleware group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
-                `For tree-shaking, use: export const ${exportedName} = () => addMiddleware('${tag}', [...])`);
+                `For tree-shaking, use: export const ${exportedName} = () => addTagMiddleware('${tag}', [...])`);
         }
         state.middleware.tagMiddleware.set(tag, {
             exportName: exportedName,
@@ -253,6 +253,34 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found tag middleware group: ${tag} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
         return;
     }
+    if (expression.text === 'addGlobalMiddleware') {
+        const middlewareArrayArg = args[0];
+        if (!middlewareArrayArg ||
+            !ts.isArrayLiteralExpression(middlewareArrayArg)) {
+            logger.error(`• addGlobalMiddleware(...) must have a literal array as its only argument`);
+            return;
+        }
+        const refs = extractMiddlewareRefs(middlewareArrayArg, checker, state.rootDir);
+        const definitionIds = refs.map((r) => r.definitionId);
+        if (definitionIds.length > 0) {
+            renameTempDefinitions(state, definitionIds, 'global', 'middleware');
+        }
+        const sourceFile = node.getSourceFile().fileName;
+        for (let i = 0; i < refs.length; i++) {
+            const instanceId = makeContextBasedId('global', 'middleware', String(i));
+            state.middleware.instances[instanceId] = {
+                definitionId: definitionIds[i],
+                sourceFile,
+                position: node.getStart(),
+                isFactoryCall: refs[i].isFactoryCall,
+            };
+        }
+        // Without this, bootstrap codegen's "import every file with a wire-call"
+        // pass skips middleware-only files and the registration never runs.
+        state.http.files.add(sourceFile);
+        logger.debug(`• Found global middleware group with ${refs.length} entries`);
+        return;
+    }
     if (expression.text === 'addHTTPMiddleware') {
         const patternArg = args[0];
         const middlewareArrayArg = args[1];
@@ -332,6 +360,7 @@ export const addMiddleware = (logger, node, checker, state) => {
             instanceIds,
             isFactory,
         });
+        state.http.files.add(sourceFile);
         logger.debug(`• Found HTTP route middleware group: ${pattern} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
         return;
     }

package/dist/add/add-permission.js

@@ -27,7 +27,7 @@ function isInsidePermissionContainer(node) {
         if (ts.isCallExpression(current) &&
             ts.isIdentifier(current.expression) &&
             (current.expression.text === 'pikkuPermissionFactory' ||
-                current.expression.text === 'addPermission' ||
+                current.expression.text === 'addTagPermission' ||
                 current.expression.text === 'addHTTPPermission')) {
             return true;
         }
@@ -247,9 +247,9 @@ export const addPermission = (logger, node, checker, state) => {
     }
     // Handle addPermission('tag', [permission1, permission2])
     // Supports two patterns:
-    // 1. export const x = () => addPermission('tag', [...])  (factory - tree-shakeable)
-    // 2. export const x = addPermission('tag', [...])  (direct - no tree-shaking)
-    if (expression.text === 'addPermission') {
+    // 1. export const x = () => addTagPermission('tag', [...])  (factory - tree-shakeable)
+    // 2. export const x = addTagPermission('tag', [...])  (direct - no tree-shaking)
+    if (expression.text === 'addTagPermission') {
         const tagArg = args[0];
         const permissionsArrayArg = args[1];
         if (!tagArg || !permissionsArrayArg)
@@ -260,13 +260,13 @@ export const addPermission = (logger, node, checker, state) => {
             tag = tagArg.text;
         }
         if (!tag) {
-            logger.warn(`• addPermission call without valid tag string`);
+            logger.warn(`• addTagPermission call without valid tag string`);
             return;
         }
         // Check if permissions is a literal array or object
         if (!ts.isArrayLiteralExpression(permissionsArrayArg) &&
             !ts.isObjectLiteralExpression(permissionsArrayArg)) {
-            logger.error(`• addPermission('${tag}', ...) must have a literal array or object as second argument`);
+            logger.error(`• addTagPermission('${tag}', ...) must have a literal array or object as second argument`);
             return;
         }
         // Extract permission pikkuFuncIds from array
@@ -305,7 +305,7 @@ export const addPermission = (logger, node, checker, state) => {
         }
         if (!isFactory && exportedName) {
             logger.warn(`• Permission group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
-                `For tree-shaking, use: export const ${exportedName} = () => addPermission('${tag}', [...])`);
+                `For tree-shaking, use: export const ${exportedName} = () => addTagPermission('${tag}', [...])`);
         }
         state.permissions.tagPermissions.set(tag, {
             exportName: exportedName,

package/dist/add/add-workflow-graph.js

@@ -281,6 +281,8 @@ function extractGraphFromNewFormat(nodesNode, configNode, checker, state) {
             input: {},
             next: undefined,
             onError: undefined,
+            retries: undefined,
+            retryDelay: undefined,
         };
     }
     // Extract config for each node from 'config' property
@@ -301,6 +303,8 @@ function extractGraphFromNewFormat(nodesNode, configNode, checker, state) {
                     nodes[nodeId].next = nodeConfig.next;
                     nodes[nodeId].onError = nodeConfig.onError;
                     nodes[nodeId].input = nodeConfig.input;
+                    nodes[nodeId].retries = nodeConfig.retries;
+                    nodes[nodeId].retryDelay = nodeConfig.retryDelay;
                 }
             }
         }
@@ -314,6 +318,8 @@ function extractNodeConfigFromObject(obj, checker) {
     let next = undefined;
     let onError = undefined;
     let input = {};
+    let retries = undefined;
+    let retryDelay = undefined;
     for (const prop of obj.properties) {
         if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
             continue;
@@ -327,8 +333,21 @@ function extractNodeConfigFromObject(obj, checker) {
         else if (propName === 'input') {
             input = extractInputMapping(prop.initializer, checker);
         }
+        else if (propName === 'retries') {
+            if (ts.isNumericLiteral(prop.initializer)) {
+                retries = Number(prop.initializer.text);
+            }
+        }
+        else if (propName === 'retryDelay') {
+            if (ts.isNumericLiteral(prop.initializer)) {
+                retryDelay = Number(prop.initializer.text);
+            }
+            else if (ts.isStringLiteral(prop.initializer)) {
+                retryDelay = prop.initializer.text;
+            }
+        }
     }
-    return { next, onError, input };
+    return { next, onError, input, retries, retryDelay };
 }
 /**
  * Inspector for pikkuWorkflowGraph() calls

package/dist/error-codes.d.ts

@@ -8,6 +8,7 @@
  */
 export declare enum ErrorCode {
     MISSING_NAME = "PKU111",
+    NON_LITERAL_WIRE_NAME = "PKU118",
     MISSING_DESCRIPTION = "PKU123",
     INVALID_VALUE = "PKU124",
     MISSING_URI = "PKU220",
@@ -41,6 +42,7 @@ export declare enum ErrorCode {
     PERMISSION_EMPTY_ARRAY = "PKU937",
     PERMISSION_PATTERN_INVALID = "PKU975",
     DUPLICATE_FUNCTION_VERSION = "PKU850",
+    DUPLICATE_FUNCTION_NAME = "PKU851",
     MANIFEST_MISSING = "PKU860",
     FUNCTION_VERSION_MODIFIED = "PKU861",
     CONTRACT_CHANGED_REQUIRES_BUMP = "PKU862",

package/dist/error-codes.js

@@ -10,6 +10,7 @@ export var ErrorCode;
 (function (ErrorCode) {
     // Validation errors
     ErrorCode["MISSING_NAME"] = "PKU111";
+    ErrorCode["NON_LITERAL_WIRE_NAME"] = "PKU118";
     ErrorCode["MISSING_DESCRIPTION"] = "PKU123";
     ErrorCode["INVALID_VALUE"] = "PKU124";
     ErrorCode["MISSING_URI"] = "PKU220";
@@ -48,6 +49,7 @@ export var ErrorCode;
     ErrorCode["PERMISSION_PATTERN_INVALID"] = "PKU975";
     // Versioning errors
     ErrorCode["DUPLICATE_FUNCTION_VERSION"] = "PKU850";
+    ErrorCode["DUPLICATE_FUNCTION_NAME"] = "PKU851";
     // Contract versioning errors
     ErrorCode["MANIFEST_MISSING"] = "PKU860";
     ErrorCode["FUNCTION_VERSION_MODIFIED"] = "PKU861";

package/dist/index.d.ts

@@ -6,6 +6,7 @@ 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 { resolveDeployTarget } from './utils/resolve-deploy-target.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';

package/dist/index.js

@@ -2,6 +2,7 @@ export { inspect, getInitialInspectorState } from './inspector.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 { resolveDeployTarget } from './utils/resolve-deploy-target.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';