@pikku/inspector 0.11.2 → 0.12.1

package/dist/utils/filter-inspector-state.js

@@ -1,4 +1,7 @@
+import { parseVersionedId } from '@pikku/core';
 import { aggregateRequiredServices } from './post-process.js';
+// Module-level Set to track warned groups across multiple filter calls
+const globalWarnedGroups = new Set();
 /**
  * Match a value against a pattern with wildcard support
  * Supports "*" at the beginning, end, or both (e.g., "send*", "*Payment", "*process*")
@@ -27,7 +30,7 @@ function matchesWildcard(value, pattern) {
 /**
  * Check if metadata matches the given filters
  */
-function matchesFilters(filters, meta, logger) {
+function matchesFilters(filters, meta, logger, warnedGroups) {
     // If no filters, allow everything
     if (Object.keys(filters).length === 0)
         return true;
@@ -66,9 +69,11 @@ function matchesFilters(filters, meta, logger) {
             return false;
         }
     }
-    // Check name filter
+    // Check name filter (match against both full ID and base name for versioned functions)
     if (filters.names && filters.names.length > 0) {
-        const nameMatches = filters.names.some((pattern) => matchesWildcard(meta.name, pattern));
+        const { baseName } = parseVersionedId(meta.name);
+        const nameMatches = filters.names.some((pattern) => matchesWildcard(meta.name, pattern) ||
+            (baseName !== meta.name && matchesWildcard(baseName, pattern)));
         if (!nameMatches) {
             logger.debug(`⒡ Filtered by name: ${meta.type}:${meta.name}`);
             return false;
@@ -81,6 +86,17 @@ function matchesFilters(filters, meta, logger) {
             logger.debug(`⒡ Filtered by HTTP route: ${meta.httpRoute}`);
             return false;
         }
+        // If route is part of a wireHTTPRoutes group, check if filter is at group level
+        if (meta.groupBasePath && warnedGroups) {
+            const groupMatches = filters.httpRoutes.some((pattern) => matchesWildcard(meta.groupBasePath, pattern) ||
+                matchesWildcard(meta.groupBasePath + '/*', pattern));
+            if (!groupMatches && !warnedGroups.has(meta.groupBasePath)) {
+                warnedGroups.add(meta.groupBasePath);
+                logger.warn(`Filtering within wireHTTPRoutes group is not yet supported. ` +
+                    `Route '${meta.httpRoute}' is part of group '${meta.groupBasePath}'. ` +
+                    `Use '--httpRoutes=${meta.groupBasePath}/*' to filter the entire group.`);
+            }
+        }
     }
     // Check HTTP method filter
     if (filters.httpMethods &&
@@ -143,6 +159,11 @@ export function filterInspectorState(state, filters, logger) {
             meta: JSON.parse(JSON.stringify(state.channels.meta)),
             files: new Set(), // Will be repopulated with filtered files
         },
+        triggers: {
+            ...state.triggers,
+            meta: JSON.parse(JSON.stringify(state.triggers?.meta ?? {})),
+            files: new Set(),
+        },
         scheduledTasks: {
             ...state.scheduledTasks,
             meta: JSON.parse(JSON.stringify(state.scheduledTasks.meta)),
@@ -158,7 +179,12 @@ export function filterInspectorState(state, filters, logger) {
             toolsMeta: JSON.parse(JSON.stringify(state.mcpEndpoints.toolsMeta)),
             resourcesMeta: JSON.parse(JSON.stringify(state.mcpEndpoints.resourcesMeta)),
             promptsMeta: JSON.parse(JSON.stringify(state.mcpEndpoints.promptsMeta)),
-            files: new Set(), // Will be repopulated with filtered files
+            files: new Set(),
+        },
+        agents: {
+            ...state.agents,
+            agentsMeta: JSON.parse(JSON.stringify(state.agents?.agentsMeta ?? {})),
+            files: new Map(),
         },
         cli: {
             ...state.cli,
@@ -172,23 +198,24 @@ export function filterInspectorState(state, filters, logger) {
         for (const route of Object.keys(routes)) {
             const routeMeta = routes[route];
             // Get function file path for directory filtering
-            const funcFile = filteredState.functions.files.get(routeMeta.pikkuFuncName);
+            const funcFile = filteredState.functions.files.get(routeMeta.pikkuFuncId);
             const filePath = funcFile?.path;
             const matches = matchesFilters(filters, {
                 type: 'http',
-                name: routeMeta.pikkuFuncName, // Use function name, not route
+                name: routeMeta.pikkuFuncId, // Use function name, not route
                 tags: routeMeta.tags,
                 filePath,
                 httpRoute: routeMeta.route,
                 httpMethod: routeMeta.method,
-            }, logger);
+                groupBasePath: routeMeta.groupBasePath,
+            }, logger, globalWarnedGroups);
             if (!matches) {
                 delete routes[route];
             }
             else {
                 // Track used functions/middleware/permissions
-                if (routeMeta.pikkuFuncName) {
-                    filteredState.serviceAggregation.usedFunctions.add(routeMeta.pikkuFuncName);
+                if (routeMeta.pikkuFuncId) {
+                    filteredState.serviceAggregation.usedFunctions.add(routeMeta.pikkuFuncId);
                 }
                 extractWireNames(routeMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
                 extractWireNames(routeMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
@@ -212,8 +239,8 @@ export function filterInspectorState(state, filters, logger) {
             delete filteredState.channels.meta[name];
         }
         else {
-            if (channelMeta.pikkuFuncName) {
-                filteredState.serviceAggregation.usedFunctions.add(channelMeta.pikkuFuncName);
+            if (channelMeta.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(channelMeta.pikkuFuncId);
             }
             extractWireNames(channelMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
             extractWireNames(channelMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
@@ -223,6 +250,27 @@ export function filterInspectorState(state, filters, logger) {
     if (Object.keys(filteredState.channels.meta).length > 0) {
         filteredState.channels.files = new Set(state.channels.files);
     }
+    // Filter triggers
+    for (const name of Object.keys(filteredState.triggers.meta)) {
+        const triggerMeta = filteredState.triggers.meta[name];
+        const matches = matchesFilters(filters, {
+            type: 'trigger',
+            name,
+            tags: triggerMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.triggers.meta[name];
+        }
+        else {
+            if (triggerMeta.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(triggerMeta.pikkuFuncId);
+            }
+        }
+    }
+    // Repopulate triggers.files if any triggers remain
+    if (Object.keys(filteredState.triggers.meta).length > 0) {
+        filteredState.triggers.files = new Set(state.triggers.files);
+    }
     // Filter scheduled tasks
     for (const name of Object.keys(filteredState.scheduledTasks.meta)) {
         const taskMeta = filteredState.scheduledTasks.meta[name];
@@ -235,8 +283,8 @@ export function filterInspectorState(state, filters, logger) {
             delete filteredState.scheduledTasks.meta[name];
         }
         else {
-            if (taskMeta.pikkuFuncName) {
-                filteredState.serviceAggregation.usedFunctions.add(taskMeta.pikkuFuncName);
+            if (taskMeta.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(taskMeta.pikkuFuncId);
             }
             extractWireNames(taskMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
         }
@@ -257,8 +305,8 @@ export function filterInspectorState(state, filters, logger) {
             delete filteredState.queueWorkers.meta[name];
         }
         else {
-            if (workerMeta.pikkuFuncName) {
-                filteredState.serviceAggregation.usedFunctions.add(workerMeta.pikkuFuncName);
+            if (workerMeta.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(workerMeta.pikkuFuncId);
             }
             extractWireNames(workerMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
         }
@@ -279,8 +327,8 @@ export function filterInspectorState(state, filters, logger) {
             delete filteredState.mcpEndpoints.toolsMeta[name];
         }
         else {
-            if (toolMeta.pikkuFuncName) {
-                filteredState.serviceAggregation.usedFunctions.add(toolMeta.pikkuFuncName);
+            if (toolMeta.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(toolMeta.pikkuFuncId);
             }
             extractWireNames(toolMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
             extractWireNames(toolMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
@@ -298,8 +346,8 @@ export function filterInspectorState(state, filters, logger) {
             delete filteredState.mcpEndpoints.resourcesMeta[name];
         }
         else {
-            if (resourceMeta.pikkuFuncName) {
-                filteredState.serviceAggregation.usedFunctions.add(resourceMeta.pikkuFuncName);
+            if (resourceMeta.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(resourceMeta.pikkuFuncId);
             }
             extractWireNames(resourceMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
             extractWireNames(resourceMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
@@ -317,8 +365,8 @@ export function filterInspectorState(state, filters, logger) {
             delete filteredState.mcpEndpoints.promptsMeta[name];
         }
         else {
-            if (promptMeta.pikkuFuncName) {
-                filteredState.serviceAggregation.usedFunctions.add(promptMeta.pikkuFuncName);
+            if (promptMeta.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(promptMeta.pikkuFuncId);
             }
             extractWireNames(promptMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
             extractWireNames(promptMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
@@ -331,6 +379,28 @@ export function filterInspectorState(state, filters, logger) {
     if (hasMcpEndpoints) {
         filteredState.mcpEndpoints.files = new Set(state.mcpEndpoints.files);
     }
+    // Filter AI agents
+    for (const name of Object.keys(filteredState.agents.agentsMeta)) {
+        const agentMeta = filteredState.agents.agentsMeta[name];
+        const matches = matchesFilters(filters, {
+            type: 'agent',
+            name,
+            tags: agentMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.agents.agentsMeta[name];
+        }
+        else {
+            if (agentMeta.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(agentMeta.pikkuFuncId);
+            }
+            extractWireNames(agentMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+            extractWireNames(agentMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+        }
+    }
+    if (Object.keys(filteredState.agents.agentsMeta).length > 0) {
+        filteredState.agents.files = new Map(state.agents.files);
+    }
     // Filter CLI programs (note: CLI filtering might be more complex with nested commands)
     const referencedRenderers = new Set();
     for (const programName of Object.keys(filteredState.cli.meta.programs)) {
@@ -347,8 +417,8 @@ export function filterInspectorState(state, filters, logger) {
                 delete programMeta.commands[commandName];
             }
             else {
-                if (commandMeta.pikkuFuncName) {
-                    filteredState.serviceAggregation.usedFunctions.add(commandMeta.pikkuFuncName);
+                if (commandMeta.pikkuFuncId) {
+                    filteredState.serviceAggregation.usedFunctions.add(commandMeta.pikkuFuncId);
                 }
                 extractWireNames(commandMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
                 // Track referenced renderers
@@ -374,6 +444,20 @@ export function filterInspectorState(state, filters, logger) {
     if (hasCliPrograms || hasCliRenderers) {
         filteredState.cli.files = new Set(state.cli.files);
     }
+    // Post-filter version expansion: include all versions of matched functions
+    const includedBaseNames = new Set();
+    for (const funcId of filteredState.serviceAggregation.usedFunctions) {
+        const { baseName } = parseVersionedId(funcId);
+        includedBaseNames.add(baseName);
+    }
+    if (includedBaseNames.size > 0) {
+        for (const funcId of Object.keys(state.functions.meta)) {
+            const { baseName } = parseVersionedId(funcId);
+            if (includedBaseNames.has(baseName)) {
+                filteredState.serviceAggregation.usedFunctions.add(funcId);
+            }
+        }
+    }
     // Recalculate requiredServices based on filtered functions/middleware/permissions
     // Need to cast to InspectorState temporarily for aggregateRequiredServices
     const stateForAggregation = filteredState;

package/dist/utils/filter-utils.d.ts

@@ -1,5 +1,5 @@
-import { InspectorFilters, InspectorLogger } from '../types.js';
-import { PikkuWiringTypes } from '@pikku/core';
+import type { InspectorFilters, InspectorLogger } from '../types.js';
+import type { PikkuWiringTypes } from '@pikku/core';
 /**
  * Match a value against a pattern with wildcard support
  * Supports "*" at the beginning, end, or both (e.g., "send*", "*Payment", "*process*")

package/dist/utils/get-files-and-methods.d.ts

@@ -1,4 +1,4 @@
-import { PathToNameAndType, InspectorState, InspectorOptions } from '../types.js';
+import type { PathToNameAndType, InspectorState, InspectorOptions } from '../types.js';
 interface Meta {
     file: string;
     variable: string;

package/dist/utils/get-property-value.d.ts

@@ -1,6 +1,10 @@
 import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
-export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | null | boolean;
+/**
+ * Extracts an array of strings from an object property.
+ */
+export declare const getArrayPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string[] | null;
+export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | number | null | boolean;
 /**
  * Extracts common wire metadata (title, tags, summary, description, errors) directly from an object
  * @param obj - The TypeScript object literal expression to extract metadata from
@@ -12,6 +16,7 @@ export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propert
 export declare const getCommonWireMetaData: (obj: ts.ObjectLiteralExpression, wiringType: string, wiringName: string | null, logger?: {
     critical: (code: ErrorCode, message: string) => void;
 }) => {
+    disabled?: true;
     title?: string;
     tags?: string[];
     summary?: string;

package/dist/utils/get-property-value.js

@@ -1,5 +1,22 @@
 import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
+/**
+ * Extracts an array of strings from an object property.
+ */
+export const getArrayPropertyValue = (obj, propertyName) => {
+    const property = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === propertyName);
+    if (property && ts.isPropertyAssignment(property)) {
+        const initializer = property.initializer;
+        if (ts.isArrayLiteralExpression(initializer)) {
+            return initializer.elements
+                .filter(ts.isStringLiteral)
+                .map((element) => element.text);
+        }
+    }
+    return null;
+};
 export const getPropertyValue = (obj, propertyName) => {
     const property = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
         ts.isIdentifier(p.name) &&
@@ -26,12 +43,16 @@ export const getPropertyValue = (obj, propertyName) => {
         if (initializer.kind === ts.SyntaxKind.FalseKeyword) {
             return false;
         }
-        // Handle string literals for other properties
+        if (ts.isNumericLiteral(initializer)) {
+            if (propertyName === 'name' || propertyName === 'schedule') {
+                return initializer.text;
+            }
+            return Number(initializer.text);
+        }
         if (ts.isStringLiteral(initializer) ||
             ts.isNoSubstitutionTemplateLiteral(initializer)) {
             return initializer.text;
         }
-        // Handle other initializer types if necessary
         return initializer.getText();
     }
     return null;
@@ -49,7 +70,11 @@ export const getCommonWireMetaData = (obj, wiringType, wiringName, logger) => {
     obj.properties.forEach((prop) => {
         if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
             const propName = prop.name.text;
-            if (propName === 'title' && ts.isStringLiteral(prop.initializer)) {
+            if (propName === 'disabled' &&
+                prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                metadata.disabled = true;
+            }
+            else if (propName === 'title' && ts.isStringLiteral(prop.initializer)) {
                 metadata.title = prop.initializer.text;
             }
             else if (propName === 'summary' &&

package/dist/utils/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function canonicalJSON(obj: unknown): string;
+export declare function hashString(input: string, length?: number): string;

package/dist/utils/hash.js

@@ -0,0 +1,23 @@
+import { createHash } from 'crypto';
+export function canonicalJSON(obj) {
+    return JSON.stringify(sortDeep(obj));
+}
+function sortDeep(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(sortDeep);
+    }
+    if (typeof value === 'object') {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = sortDeep(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+export function hashString(input, length = 16) {
+    return createHash('sha256').update(input).digest('hex').slice(0, length);
+}

package/dist/utils/middleware.d.ts

@@ -1,39 +1,16 @@
 import * as ts from 'typescript';
-import { MiddlewareMetadata } from '@pikku/core';
-import { InspectorState } from '../types.js';
-/**
- * Extract middleware pikkuFuncNames from an array literal expression
- * Resolves each identifier to its pikkuFuncName using extractFunctionName
- * Also handles call expressions (like logCommandInfoAndTime({...}))
- */
+import type { MiddlewareMetadata } from '@pikku/core';
+import type { InspectorState } from '../types.js';
+export interface MiddlewareRef {
+    definitionId: string;
+    isFactoryCall: boolean;
+}
+export declare function extractMiddlewareRefs(arrayNode: ts.Expression, checker: ts.TypeChecker, rootDir: string): MiddlewareRef[];
 export declare function extractMiddlewarePikkuNames(arrayNode: ts.Expression, checker: ts.TypeChecker, rootDir: string): string[];
-/**
- * Get middleware array from an object literal expression property
- * Returns the initializer node for the 'middleware' property if it exists
- */
 export declare function getMiddlewareNode(obj: ts.ObjectLiteralExpression): ts.Expression | undefined;
-/**
- * Check if a route matches a pattern with wildcards
- * Pattern can be exact match or use * as wildcard
- * e.g., '/api/*' matches '/api/users', '/api/posts/123', etc.
- */
 export declare function routeMatchesPattern(route: string, pattern: string): boolean;
-/**
- * Resolve middleware for an HTTP wiring based on:
- * 1. Global HTTP middleware (addd([...]))
- * 2. Route-specific HTTP middleware (addHTTPMiddleware('/pattern', [...]))
- * 3. Tag-based middleware (addMiddleware('tag', [...]))
- * 4. Explicit wiring middleware (wireHTTP({ middleware: [...] }))
- * Returns undefined if no middleware is found, otherwise returns array with at least one item
- */
 export declare function resolveHTTPMiddleware(state: InspectorState, route: string, tags: string[] | undefined, explicitMiddlewareNode: ts.Expression | undefined, checker: ts.TypeChecker): MiddlewareMetadata[] | undefined;
-/**
- * Convenience wrapper: Extract middleware node from object and resolve
- * Use this in add-* files for cleaner code
- */
 export declare function resolveMiddleware(state: InspectorState, obj: ts.ObjectLiteralExpression, tags: string[] | undefined, checker: ts.TypeChecker): MiddlewareMetadata[] | undefined;
-/**
- * Convenience wrapper for HTTP: Extract middleware and resolve with HTTP-specific logic
- * Use this in add-http-route.ts for cleaner code
- */
 export declare function resolveHTTPMiddlewareFromObject(state: InspectorState, route: string, obj: ts.ObjectLiteralExpression, tags: string[] | undefined, checker: ts.TypeChecker): MiddlewareMetadata[] | undefined;
+export declare function resolveAIMiddleware(state: InspectorState, obj: ts.ObjectLiteralExpression, checker: ts.TypeChecker): MiddlewareMetadata[] | undefined;
+export declare function resolveChannelMiddleware(state: InspectorState, obj: ts.ObjectLiteralExpression, tags: string[] | undefined, checker: ts.TypeChecker): MiddlewareMetadata[] | undefined;

package/dist/utils/middleware.js

@@ -1,80 +1,64 @@
 import * as ts from 'typescript';
 import { extractFunctionName } from './extract-function-name.js';
-/**
- * Extract middleware pikkuFuncNames from an array literal expression
- * Resolves each identifier to its pikkuFuncName using extractFunctionName
- * Also handles call expressions (like logCommandInfoAndTime({...}))
- */
-export function extractMiddlewarePikkuNames(arrayNode, checker, rootDir) {
+export function extractMiddlewareRefs(arrayNode, checker, rootDir) {
     if (!ts.isArrayLiteralExpression(arrayNode)) {
         return [];
     }
-    const names = [];
+    const refs = [];
     for (const element of arrayNode.elements) {
         if (ts.isIdentifier(element)) {
-            // Resolve the identifier to its pikkuFuncName
-            const { pikkuFuncName } = extractFunctionName(element, checker, rootDir);
-            names.push(pikkuFuncName);
+            const { pikkuFuncId } = extractFunctionName(element, checker, rootDir);
+            refs.push({
+                definitionId: pikkuFuncId.startsWith('__temp_')
+                    ? element.text
+                    : pikkuFuncId,
+                isFactoryCall: false,
+            });
         }
         else if (ts.isCallExpression(element)) {
-            // Handle call expressions like rateLimiter(10) or logCommandInfoAndTime({...})
-            // Extract the function being called (e.g., 'rateLimiter' from 'rateLimiter(10)')
-            const { pikkuFuncName } = extractFunctionName(element.expression, checker, rootDir);
-            names.push(pikkuFuncName);
+            const { pikkuFuncId } = extractFunctionName(element.expression, checker, rootDir);
+            refs.push({
+                definitionId: pikkuFuncId.startsWith('__temp_') &&
+                    ts.isIdentifier(element.expression)
+                    ? element.expression.text
+                    : pikkuFuncId,
+                isFactoryCall: true,
+            });
         }
     }
-    return names;
+    return refs;
+}
+export function extractMiddlewarePikkuNames(arrayNode, checker, rootDir) {
+    return extractMiddlewareRefs(arrayNode, checker, rootDir).map((r) => r.definitionId);
 }
-/**
- * Get middleware array from an object literal expression property
- * Returns the initializer node for the 'middleware' property if it exists
- */
 export function getMiddlewareNode(obj) {
     const middlewareProp = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
         ts.isIdentifier(p.name) &&
         p.name.text === 'middleware');
     return middlewareProp?.initializer;
 }
-/**
- * Check if a route matches a pattern with wildcards
- * Pattern can be exact match or use * as wildcard
- * e.g., '/api/*' matches '/api/users', '/api/posts/123', etc.
- */
 export function routeMatchesPattern(route, pattern) {
     if (route === pattern)
         return true;
-    // Convert pattern to regex: replace * with .*
     const regexPattern = pattern
-        .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape regex special chars except *
-        .replace(/\*/g, '.*'); // Replace * with .*
+        .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*');
     const regex = new RegExp(`^${regexPattern}$`);
     return regex.test(route);
 }
-/**
- * Resolve middleware for an HTTP wiring based on:
- * 1. Global HTTP middleware (addd([...]))
- * 2. Route-specific HTTP middleware (addHTTPMiddleware('/pattern', [...]))
- * 3. Tag-based middleware (addMiddleware('tag', [...]))
- * 4. Explicit wiring middleware (wireHTTP({ middleware: [...] }))
- * Returns undefined if no middleware is found, otherwise returns array with at least one item
- */
 export function resolveHTTPMiddleware(state, route, tags, explicitMiddlewareNode, checker) {
     const resolved = [];
-    // 1. HTTP route middleware groups (includes '*' for global)
     for (const [pattern, _groupMeta] of state.http.routeMiddleware.entries()) {
         if (routeMatchesPattern(route, pattern)) {
-            // Just reference the group by route pattern
             resolved.push({
                 type: 'http',
                 route: pattern,
             });
         }
     }
-    // 2. Tag-based middleware groups
     if (tags && tags.length > 0) {
         for (const tag of tags) {
             if (state.middleware.tagMiddleware.has(tag)) {
-                // Just reference the group by tag
                 resolved.push({
                     type: 'tag',
                     tag,
@@ -82,32 +66,24 @@ export function resolveHTTPMiddleware(state, route, tags, explicitMiddlewareNode
             }
         }
     }
-    // 3. Explicit wire middleware (inline is OK here)
     if (explicitMiddlewareNode) {
         const middlewareNames = extractMiddlewarePikkuNames(explicitMiddlewareNode, checker, state.rootDir);
         for (const name of middlewareNames) {
-            const meta = state.middleware.meta[name];
+            const def = state.middleware.definitions[name];
             resolved.push({
                 type: 'wire',
                 name,
-                inline: meta?.exportedName === null,
+                inline: def?.exportedName === null,
             });
         }
     }
     return resolved.length > 0 ? resolved : undefined;
 }
-/**
- * Resolve tag-based and explicit middleware (common logic for wires and functions)
- * 1. Tag-based middleware (addMiddleware('tag', [...]))
- * 2. Explicit middleware (wireHTTP/pikkuFunc({ middleware: [...] }))
- */
 function resolveTagAndExplicitMiddleware(state, tags, explicitMiddlewareNode, checker) {
     const resolved = [];
-    // 1. Tag-based middleware groups
     if (tags && tags.length > 0) {
         for (const tag of tags) {
             if (state.middleware.tagMiddleware.has(tag)) {
-                // Just reference the group by tag
                 resolved.push({
                     type: 'tag',
                     tag,
@@ -115,43 +91,81 @@ function resolveTagAndExplicitMiddleware(state, tags, explicitMiddlewareNode, ch
             }
         }
     }
-    // 2. Explicit middleware (inline is OK here - used directly in wire/function)
     if (explicitMiddlewareNode) {
         const middlewareNames = extractMiddlewarePikkuNames(explicitMiddlewareNode, checker, state.rootDir);
         for (const name of middlewareNames) {
-            const meta = state.middleware.meta[name];
+            const def = state.middleware.definitions[name];
             resolved.push({
                 type: 'wire',
                 name,
-                inline: meta?.exportedName === null,
+                inline: def?.exportedName === null,
             });
         }
     }
     return resolved;
 }
-/**
- * Resolve middleware for a function based on:
- * 1. Tag-based middleware (addMiddleware('tag', [...]))
- * 2. Explicit function middleware (pikkuFunc({ middleware: [...] }))
- * Returns undefined if no middleware is found, otherwise returns array with at least one item
- */
 function resolveFunctionMiddlewareInternal(state, tags, explicitMiddlewareNode, checker) {
     const resolved = resolveTagAndExplicitMiddleware(state, tags, explicitMiddlewareNode, checker);
     return resolved.length > 0 ? resolved : undefined;
 }
-/**
- * Convenience wrapper: Extract middleware node from object and resolve
- * Use this in add-* files for cleaner code
- */
 export function resolveMiddleware(state, obj, tags, checker) {
     const explicitMiddlewareNode = getMiddlewareNode(obj);
     return resolveFunctionMiddlewareInternal(state, tags, explicitMiddlewareNode, checker);
 }
-/**
- * Convenience wrapper for HTTP: Extract middleware and resolve with HTTP-specific logic
- * Use this in add-http-route.ts for cleaner code
- */
 export function resolveHTTPMiddlewareFromObject(state, route, obj, tags, checker) {
     const explicitMiddlewareNode = getMiddlewareNode(obj);
     return resolveHTTPMiddleware(state, route, tags, explicitMiddlewareNode, checker);
 }
+function getAIMiddlewareNode(obj) {
+    const prop = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'aiMiddleware');
+    return prop?.initializer;
+}
+export function resolveAIMiddleware(state, obj, checker) {
+    const explicitNode = getAIMiddlewareNode(obj);
+    if (!explicitNode)
+        return undefined;
+    const names = extractMiddlewarePikkuNames(explicitNode, checker, state.rootDir);
+    const resolved = names.map((name) => {
+        const def = state.aiMiddleware.definitions[name];
+        return {
+            type: 'wire',
+            name,
+            inline: def?.exportedName === null,
+        };
+    });
+    return resolved.length > 0 ? resolved : undefined;
+}
+function getChannelMiddlewareNode(obj) {
+    const prop = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'channelMiddleware');
+    return prop?.initializer;
+}
+export function resolveChannelMiddleware(state, obj, tags, checker) {
+    const resolved = [];
+    if (tags && tags.length > 0) {
+        for (const tag of tags) {
+            if (state.channelMiddleware.tagMiddleware.has(tag)) {
+                resolved.push({
+                    type: 'tag',
+                    tag,
+                });
+            }
+        }
+    }
+    const explicitNode = getChannelMiddlewareNode(obj);
+    if (explicitNode) {
+        const names = extractMiddlewarePikkuNames(explicitNode, checker, state.rootDir);
+        for (const name of names) {
+            const def = state.channelMiddleware.definitions[name];
+            resolved.push({
+                type: 'wire',
+                name,
+                inline: def?.exportedName === null,
+            });
+        }
+    }
+    return resolved.length > 0 ? resolved : undefined;
+}