@pikku/cli 0.12.144 → 0.12.145

package/dist/src/deploy/analyzer/analyzer.js

@@ -9,6 +9,8 @@
 import { resolveDeployTarget, } from '@pikku/inspector';
 import { relative } from 'node:path';
 import { isScenarioFunction, withoutScenarios, withoutScenarioWorkflows, } from '../../functions/wirings/scenarios/scenario-partition.js';
+import { toSafeKebab } from './naming.js';
+import { createUnitResolver } from './grouping.js';
 export function analyzeDeployment(state, options) {
     const serverlessIncompatible = new Set(options.serverlessIncompatible ?? []);
     const defaultTarget = options.defaultTarget ?? 'serverless';
@@ -30,6 +32,86 @@ export function analyzeDeployment(state, options) {
     const functionsMeta = withoutScenarios(state.functions.meta);
     const graphMeta = withoutScenarioWorkflows(state.workflows.graphMeta);
     const httpMeta = state.http.meta;
+    const tagIndex = buildFunctionTagIndex(state, functionsMeta);
+    const tagsFor = (funcId) => tagIndex.get(funcId) ?? [];
+    const resolver = createUnitResolver(options.grouping, {
+        routesForFunction: (funcId) => collectHttpRoutes(httpMeta, funcId).flatMap((r) => [
+            r.route,
+            prefixed(r.route),
+        ]),
+        tagsForFunction: tagsFor,
+    });
+    const addFunctionUnit = (unit) => {
+        const existing = units.find((u) => u.name === unit.name);
+        if (!existing) {
+            units.push(unit);
+            return;
+        }
+        if (existing.target !== unit.target) {
+            const rule = resolver.ruleForUnit(unit.name);
+            throw new Error(`deploy.grouping: unit "${unit.name}" would hold both serverless and server functions ` +
+                `(${existing.functionIds.join(', ')} vs ${unit.functionIds.join(', ')}). ` +
+                (rule
+                    ? `Give the server-target functions their own rule, or drop them from "${unit.name}".`
+                    : `A grouping rule cannot change a function's target.`));
+        }
+        for (const id of unit.functionIds) {
+            if (!existing.functionIds.includes(id)) {
+                existing.functionIds.push(id);
+            }
+        }
+        for (const service of unit.services) {
+            if (!existing.services.some((s) => s.capability === service.capability &&
+                s.sourceServiceName === service.sourceServiceName)) {
+                existing.services.push(service);
+            }
+        }
+        for (const dep of unit.dependsOn) {
+            if (dep !== existing.name && !existing.dependsOn.includes(dep)) {
+                existing.dependsOn.push(dep);
+            }
+        }
+        for (const tag of unit.tags) {
+            if (!existing.tags.includes(tag)) {
+                existing.tags.push(tag);
+            }
+        }
+        for (const handler of unit.handlers) {
+            if (handler.type === 'fetch') {
+                const fetchHandler = existing.handlers.find((h) => h.type === 'fetch');
+                if (fetchHandler) {
+                    fetchHandler.routes.push(...handler.routes);
+                }
+                else {
+                    existing.handlers.push(handler);
+                }
+            }
+            else {
+                existing.handlers.push(handler);
+            }
+        }
+        if (unit.invokedAgents?.length) {
+            const merged = new Set([
+                ...(existing.invokedAgents ?? []),
+                ...unit.invokedAgents,
+            ]);
+            existing.invokedAgents = [...merged];
+        }
+    };
+    const unitFunctionIds = new Map();
+    const unitFor = (funcId) => {
+        const name = resolver.forFunction(funcId);
+        const existing = unitFunctionIds.get(name);
+        if (existing) {
+            if (!existing.includes(funcId)) {
+                existing.push(funcId);
+            }
+        }
+        else {
+            unitFunctionIds.set(name, [funcId]);
+        }
+        return name;
+    };
     // ── Step 1: Create function units ──────────────────────────────────
     // Each function gets one unit. Collect all its triggers.
     for (const [funcId, funcMeta] of entries(functionsMeta)) {
@@ -70,7 +152,7 @@ export function analyzeDeployment(state, options) {
                 handlers.push({ type: 'queue', queueName: queueMeta.name ?? queueName });
                 queues.push({
                     name: queueMeta.name ?? queueName,
-                    consumerUnit: toSafeKebab(funcId),
+                    consumerUnit: unitFor(funcId),
                     consumerFunctionId: funcId,
                 });
             }
@@ -86,7 +168,7 @@ export function analyzeDeployment(state, options) {
                 scheduledTasks.push({
                     name: schedMeta.name,
                     schedule: schedMeta.schedule,
-                    unitName: toSafeKebab(funcId),
+                    unitName: unitFor(funcId),
                     functionId: funcId,
                 });
             }
@@ -128,15 +210,15 @@ export function analyzeDeployment(state, options) {
             continue;
         }
         const invokedAgents = collectInvokedAgents(state, funcId);
-        units.push({
-            name: toSafeKebab(funcId),
+        addFunctionUnit({
+            name: unitFor(funcId),
             role: 'function',
             target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
             functionIds: [funcId],
             services: withAgentServices(collectServicesForFunction(funcMeta), invokedAgents),
             dependsOn: [],
             handlers,
-            tags: funcMeta.tags ?? [],
+            tags: tagsFor(funcId),
             ...(invokedAgents.length > 0 && { invokedAgents }),
         });
     }
@@ -147,7 +229,7 @@ export function analyzeDeployment(state, options) {
         if (exposed.length === 0) {
             continue;
         }
-        const unitName = `addon-${toSafeKebab(namespace)}`;
+        const unitName = resolver.forAddon(namespace);
         const addonIncompatible = new Set(state.addonServerlessIncompatible?.get(namespace) ?? []);
         const routes = [];
         const functionIds = [];
@@ -176,7 +258,7 @@ export function analyzeDeployment(state, options) {
                 target = 'server';
             }
         }
-        units.push({
+        addFunctionUnit({
             name: unitName,
             role: 'function',
             target,
@@ -193,7 +275,7 @@ export function analyzeDeployment(state, options) {
         const subAgentNames = agentMeta.agents ?? [];
         const unitName = `agent-${toSafeKebab(agentName)}`;
         // Agent gateway depends on its tool function units
-        const toolUnitNames = toolIds.map((id) => toSafeKebab(id));
+        const toolUnitNames = toolIds.map((id) => unitFor(id));
         const subAgentUnitNames = subAgentNames.map((sa) => `agent-${toSafeKebab(sa)}`);
         // Agent needs AI services
         const agentServices = agentServiceRequirements();
@@ -271,7 +353,7 @@ export function analyzeDeployment(state, options) {
     const allMcpIds = [...mcpToolIds, ...mcpResourceIds, ...mcpPromptIds];
     if (allMcpIds.length > 0) {
         const unitName = 'mcp-server';
-        const mcpFuncUnitNames = allMcpIds.map((id) => toSafeKebab(id));
+        const mcpFuncUnitNames = allMcpIds.map((id) => unitFor(id));
         units.push({
             name: unitName,
             role: 'mcp',
@@ -280,7 +362,7 @@ export function analyzeDeployment(state, options) {
             services: [],
             dependsOn: mcpFuncUnitNames,
             handlers: [{ type: 'fetch', routes: [] }],
-            tags: collectTags(allMcpIds, functionsMeta),
+            tags: collectTags(allMcpIds, tagsFor),
         });
         mcpEndpoints.push({
             unitName,
@@ -295,7 +377,7 @@ export function analyzeDeployment(state, options) {
         if (funcIds.length === 0)
             continue;
         const unitName = `channel-${toSafeKebab(channelName)}`;
-        const funcUnitNames = funcIds.map((id) => toSafeKebab(id));
+        const funcUnitNames = funcIds.map((id) => unitFor(id));
         units.push({
             name: unitName,
             role: 'channel',
@@ -314,34 +396,35 @@ export function analyzeDeployment(state, options) {
         });
     }
     // ── Step 5: Workflows ──────────────────────────────────────────────
-    buildWorkflows(graphMeta, functionsMeta, { ...state.rpc?.exposedMeta, ...state.rpc?.internalMeta }, httpMeta, units, workflows, queues, workflowQueues);
+    buildWorkflows(graphMeta, functionsMeta, { ...state.rpc?.exposedMeta, ...state.rpc?.internalMeta }, httpMeta, units, workflows, queues, workflowQueues, unitFor);
     // ── Step 6: Ensure function units exist for gateway dependencies ───
     // Gateways depend on function units. If a function is only used via
     // a gateway (not directly wired to HTTP/queue/cron), it still needs
     // a unit with a fetch handler for RPC access.
-    const existingUnitNames = new Set(units.map((u) => u.name));
     const unitsSnapshot = Array.from(units);
     for (const unit of unitsSnapshot) {
         for (const dep of unit.dependsOn) {
-            if (!existingUnitNames.has(dep)) {
-                // Find the function ID for this dependency
-                const funcId = fromKebab(dep);
+            for (const funcId of unitFunctionIds.get(dep) ?? []) {
+                const existing = units.find((u) => u.name === dep);
+                if (existing?.functionIds.includes(funcId)) {
+                    continue;
+                }
                 const funcMeta = functionsMeta[funcId];
-                if (funcMeta) {
-                    const invokedAgents = collectInvokedAgents(state, funcId);
-                    units.push({
-                        name: dep,
-                        role: 'function',
-                        target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
-                        functionIds: [funcId],
-                        services: withAgentServices(collectServicesForFunction(funcMeta), invokedAgents),
-                        dependsOn: [],
-                        handlers: [{ type: 'fetch', routes: [] }],
-                        tags: funcMeta.tags ?? [],
-                        ...(invokedAgents.length > 0 && { invokedAgents }),
-                    });
-                    existingUnitNames.add(dep);
+                if (!funcMeta) {
+                    continue;
                 }
+                const invokedAgents = collectInvokedAgents(state, funcId);
+                addFunctionUnit({
+                    name: dep,
+                    role: 'function',
+                    target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
+                    functionIds: [funcId],
+                    services: withAgentServices(collectServicesForFunction(funcMeta), invokedAgents),
+                    dependsOn: [],
+                    handlers: [{ type: 'fetch', routes: [] }],
+                    tags: tagsFor(funcId),
+                    ...(invokedAgents.length > 0 && { invokedAgents }),
+                });
             }
         }
     }
@@ -557,7 +640,7 @@ export function analyzeDeployment(state, options) {
 // ---------------------------------------------------------------------------
 // Workflow builder
 // ---------------------------------------------------------------------------
-function buildWorkflows(graphMeta, functionsMeta, rpcMeta, _httpMeta, units, workflows, queues, workflowQueues) {
+function buildWorkflows(graphMeta, functionsMeta, rpcMeta, _httpMeta, units, workflows, queues, workflowQueues, unitFor) {
     for (const [_wfName, graph] of entries(graphMeta)) {
         const steps = [];
         const stepUnitNames = [];
@@ -566,7 +649,7 @@ function buildWorkflows(graphMeta, functionsMeta, rpcMeta, _httpMeta, units, wor
                 continue;
             if (!('rpcName' in node))
                 continue;
-            const stepUnitName = toSafeKebab(node.rpcName);
+            const stepUnitName = unitFor(node.rpcName);
             // Step dispatch is decided per-function: a step runs inline unless its
             // function is marked `workflowQueued: true` (then it dispatches via queue).
             const stepFuncId = rpcMeta[node.rpcName] ?? node.rpcName;
@@ -654,7 +737,7 @@ function buildWorkflows(graphMeta, functionsMeta, rpcMeta, _httpMeta, units, wor
                 const stepQueueName = `wf-step-${toSafeKebab(step.functionId)}`;
                 queues.push({
                     name: stepQueueName,
-                    consumerUnit: toSafeKebab(step.functionId),
+                    consumerUnit: unitFor(step.functionId),
                     consumerFunctionId: `pikkuWorkflowWorker:${step.functionId}`,
                 });
             }
@@ -797,32 +880,71 @@ function collectChannelFunctionIds(channelMeta) {
 // ---------------------------------------------------------------------------
 // Naming helpers
 // ---------------------------------------------------------------------------
-export function toSafeKebab(str) {
-    return str
-        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-        .replace(/[:/\\]/g, '-')
-        .replace(/--+/g, '-')
-        .replace(/^-|-$/g, '')
-        .toLowerCase();
-}
-function fromKebab(str) {
-    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
+export { toSafeKebab } from './naming.js';
 // ---------------------------------------------------------------------------
 // Tag helpers
 // ---------------------------------------------------------------------------
-function collectTags(funcIds, functionsMeta) {
+function collectTags(funcIds, tagsFor) {
     const tags = new Set();
     for (const id of funcIds) {
-        const meta = functionsMeta[id];
-        if (meta?.tags) {
-            for (const tag of meta.tags)
-                tags.add(tag);
-        }
+        for (const tag of tagsFor(id))
+            tags.add(tag);
     }
     return [...tags];
 }
+/**
+ * Every tag that applies to a function, from the function itself and from every
+ * wiring that reaches it.
+ *
+ * Tags are almost always written on the wiring — `wireHTTP({ tags: ['todos'] })`
+ * — not on the `pikkuFunc`, so reading `FunctionMeta.tags` alone sees nothing in
+ * a typical project. `deploy.grouping` matches on the tags a user actually
+ * wrote, which means the union.
+ */
+function buildFunctionTagIndex(state, functionsMeta) {
+    const index = new Map();
+    const add = (funcId, tags) => {
+        if (!funcId || !tags?.length)
+            return;
+        let set = index.get(funcId);
+        if (!set) {
+            set = new Set();
+            index.set(funcId, set);
+        }
+        for (const tag of tags)
+            set.add(tag);
+    };
+    for (const [funcId, meta] of entries(functionsMeta)) {
+        add(funcId, meta.tags);
+    }
+    for (const method of HTTP_METHODS) {
+        const methodRoutes = state.http?.meta?.[method];
+        if (!methodRoutes)
+            continue;
+        for (const routeMeta of values(methodRoutes)) {
+            add(routeMeta.pikkuFuncId, routeMeta.tags);
+        }
+    }
+    for (const meta of values(state.queueWorkers?.meta ?? {})) {
+        add(meta.pikkuFuncId, meta.tags);
+    }
+    for (const meta of values(state.scheduledTasks?.meta ?? {})) {
+        add(meta.pikkuFuncId, meta.tags);
+    }
+    for (const meta of [
+        ...values(state.mcpEndpoints?.toolsMeta ?? {}),
+        ...values(state.mcpEndpoints?.resourcesMeta ?? {}),
+        ...values(state.mcpEndpoints?.promptsMeta ?? {}),
+    ]) {
+        add(meta.pikkuFuncId, meta.tags);
+    }
+    for (const channelMeta of values(state.channels?.meta ?? {})) {
+        for (const funcId of collectChannelFunctionIds(channelMeta)) {
+            add(funcId, channelMeta.tags);
+        }
+    }
+    return new Map([...index].map(([funcId, tags]) => [funcId, [...tags]]));
+}
 // ---------------------------------------------------------------------------
 // Typed iteration helpers
 // ---------------------------------------------------------------------------

package/dist/src/deploy/analyzer/grouping.d.ts

@@ -0,0 +1,23 @@
+export type GroupingStrategy = 'function' | 'single';
+export interface GroupingRule {
+    unit: string;
+    tags?: string[];
+    addon?: string;
+    routes?: string[];
+}
+export interface GroupingConfig {
+    strategy?: GroupingStrategy;
+    rules?: GroupingRule[];
+}
+export interface UnitResolverInput {
+    routesForFunction: (funcId: string) => string[];
+    tagsForFunction: (funcId: string) => string[];
+}
+export interface UnitResolver {
+    forFunction: (funcId: string) => string;
+    forAddon: (namespace: string) => string;
+    isGrouped: boolean;
+    ruleForUnit: (unitName: string) => GroupingRule | undefined;
+}
+export declare const validateGrouping: (config: GroupingConfig) => void;
+export declare const createUnitResolver: (config: GroupingConfig | undefined, input: UnitResolverInput) => UnitResolver;

package/dist/src/deploy/analyzer/grouping.js

@@ -0,0 +1,74 @@
+import { toSafeKebab } from './naming.js';
+const SINGLE_UNIT_NAME = 'app';
+const routeMatcher = (pattern) => {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
+};
+export const validateGrouping = (config) => {
+    const rules = config.rules ?? [];
+    const seen = new Set();
+    for (const rule of rules) {
+        if (!rule.unit) {
+            throw new Error(`deploy.grouping: every rule needs a "unit" name (offending rule: ${JSON.stringify(rule)})`);
+        }
+        if (seen.has(rule.unit)) {
+            throw new Error(`deploy.grouping: two rules both name the unit "${rule.unit}". Merge them into one rule.`);
+        }
+        seen.add(rule.unit);
+        if (!rule.tags?.length && !rule.addon && !rule.routes?.length) {
+            throw new Error(`deploy.grouping: rule "${rule.unit}" matches nothing. Give it at least one of "tags", "addon" or "routes".`);
+        }
+    }
+};
+export const createUnitResolver = (config, input) => {
+    const strategy = config?.strategy ?? 'function';
+    const rules = config?.rules ?? [];
+    if (config) {
+        validateGrouping(config);
+    }
+    const compiled = rules.map((rule) => ({
+        rule,
+        unit: toSafeKebab(rule.unit),
+        tags: rule.tags,
+        addon: rule.addon,
+        routes: rule.routes?.map(routeMatcher),
+    }));
+    const byUnitName = new Map(compiled.map((c) => [c.unit, c.rule]));
+    const matches = (c, tags, routes, addon) => {
+        if (c.tags && !c.tags.some((tag) => tags.includes(tag))) {
+            return false;
+        }
+        if (c.addon && c.addon !== addon) {
+            return false;
+        }
+        if (c.routes && !c.routes.some((re) => routes.some((r) => re.test(r)))) {
+            return false;
+        }
+        return true;
+    };
+    const fallback = (funcId) => strategy === 'single' ? SINGLE_UNIT_NAME : toSafeKebab(funcId);
+    return {
+        isGrouped: strategy !== 'function' || compiled.length > 0,
+        ruleForUnit: (unitName) => byUnitName.get(unitName),
+        forFunction: (funcId) => {
+            if (compiled.length > 0) {
+                const tags = input.tagsForFunction(funcId);
+                const routes = input.routesForFunction(funcId);
+                for (const c of compiled) {
+                    if (matches(c, tags, routes, undefined)) {
+                        return c.unit;
+                    }
+                }
+            }
+            return fallback(funcId);
+        },
+        forAddon: (namespace) => {
+            for (const c of compiled) {
+                if (c.addon === namespace && !c.tags && !c.routes) {
+                    return c.unit;
+                }
+            }
+            return `addon-${toSafeKebab(namespace)}`;
+        },
+    };
+};

package/dist/src/deploy/analyzer/index.d.ts

@@ -1,2 +1,3 @@
 export { analyzeDeployment } from './analyzer.js';
 export type { AnalyzerOptions } from './analyzer.js';
+export type { GroupingConfig, GroupingRule, GroupingStrategy, } from './grouping.js';

package/dist/src/deploy/analyzer/naming.d.ts

@@ -0,0 +1 @@
+export declare function toSafeKebab(str: string): string;

package/dist/src/deploy/analyzer/naming.js

@@ -0,0 +1,9 @@
+export function toSafeKebab(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .replace(/[:/\\]/g, '-')
+        .replace(/--+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase();
+}

package/dist/src/deploy/build-pipeline.d.ts

@@ -6,6 +6,7 @@
  */
 import type { InspectorState } from '@pikku/inspector';
 import { PikkuError } from '@pikku/core/errors';
+import type { GroupingConfig } from './analyzer/index.js';
 import type { DeploymentManifest } from '@pikku/deploy';
 import type { Bundler } from './bundler/bundler.interface.js';
 import type { BundleResult } from './bundler/types.js';
@@ -50,6 +51,7 @@ export declare function runBuildPipeline(options: {
     inspectorState: InspectorState;
     serverlessIncompatible?: string[];
     defaultTarget?: 'serverless' | 'server';
+    grouping?: GroupingConfig;
     globalHTTPPrefix?: string;
     getEntryContext: (unitDir: string, pikkuDir: string, unit: DeploymentManifest['units'][0], state: InspectorState) => unknown;
     /**

package/dist/src/deploy/build-pipeline.js

@@ -153,6 +153,7 @@ export async function runBuildPipeline(options) {
         projectId,
         serverlessIncompatible: options.serverlessIncompatible,
         defaultTarget: options.defaultTarget,
+        grouping: options.grouping,
         globalHTTPPrefix: options.globalHTTPPrefix,
         workflowQueues,
     });
@@ -299,7 +300,26 @@ export async function runBuildPipeline(options) {
                 unitPikkuDirs.set(k, v);
             codegenErrors.push(...serverCodegenErrors);
             // Replace individual server units with the merged one in the manifest
+            const mergedNames = new Set(serverUnits.map((u) => u.name));
             manifest.units = [...serverlessUnits, mergedServerUnit];
+            // Anything that named one of the units just folded away has to follow it,
+            // or the manifest ships a queue consumer and a cron pointing at a unit
+            // that no longer exists.
+            for (const queue of manifest.queues) {
+                if (mergedNames.has(queue.consumerUnit)) {
+                    queue.consumerUnit = serverUnitName;
+                }
+            }
+            for (const task of manifest.scheduledTasks) {
+                if (mergedNames.has(task.unitName)) {
+                    task.unitName = serverUnitName;
+                }
+            }
+            for (const unit of manifest.units) {
+                unit.dependsOn = [
+                    ...new Set(unit.dependsOn.map((dep) => mergedNames.has(dep) ? serverUnitName : dep)),
+                ].filter((dep) => dep !== unit.name);
+            }
             logger.info(`  Server container: ${serverUnits.length} functions merged into one unit`);
         }
         logger.info(`Codegen complete: ${unitPikkuDirs.size} units`);

package/dist/src/functions/commands/deploy-apply.js

@@ -217,6 +217,7 @@ export const deployApply = pikkuSessionlessFunc({
             inspectorState,
             serverlessIncompatible: config.deploy?.serverlessIncompatible,
             defaultTarget: config.deploy?.defaultTarget,
+            grouping: config.deploy?.grouping,
             globalHTTPPrefix: config.globalHTTPPrefix,
             getEntryContext,
             frontend: config.frontend,

package/dist/src/functions/commands/deploy-plan.js

@@ -57,6 +57,7 @@ export const deployPlan = pikkuSessionlessFunc({
             inspectorState,
             serverlessIncompatible: config.deploy?.serverlessIncompatible,
             defaultTarget: config.deploy?.defaultTarget,
+            grouping: config.deploy?.grouping,
             globalHTTPPrefix: config.globalHTTPPrefix,
             getEntryContext,
             frontend: config.frontend,