@pikku/cli 0.11.3 → 0.12.1

package/dist/src/functions/wirings/workflow/serialize-workflow-types.js

@@ -1,31 +1,26 @@
-/**
- * Generate all workflow type helpers for authoring workflows
- * Combines DSL helpers (pikkuWorkflowFunc, pikkuWorkflowComplexFunc) and
- * graph helpers (pikkuWorkflowGraph) with unified wireWorkflow
- */
-export const serializeWorkflowTypes = (functionTypesImportPath, rpcMapImportPath) => {
-    return `/**
- * Workflow type definitions and helpers
- * Used for authoring both DSL and graph-based workflows
- */
+export const serializeWorkflowTypes = (functionTypesImportPath, rpcMapImportPath, workflowMapImportPath) => {
+    return `import { WorkflowCancelledException } from '@pikku/core/workflow'
+import {
+  workflow as coreWorkflow,
+  workflowStart as coreWorkflowStart,
+  workflowStatus as coreWorkflowStatus,
+  graphStart as coreGraphStart,
+} from '@pikku/core/workflow'
+import { template } from '@pikku/core/workflow'
+import {
+  pikkuWorkflowGraph as corePikkuWorkflowGraph,
+  type PikkuWorkflowGraphConfig,
+  type PikkuWorkflowGraphResult,
+} from '@pikku/core/workflow'
+import type { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow'
 
-import { PikkuWorkflowWire, WorkflowStepOptions, WorkflowCancelledException } from '@pikku/core/workflow'
-
-// Re-export WorkflowCancelledException for use in workflow functions
 export { WorkflowCancelledException }
 import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '${functionTypesImportPath}'
 import type { RPCMap, FlattenedRPCMap } from '${rpcMapImportPath}'
-import type { GraphNodeConfig, HTTPMethod } from '@pikku/core'
-import { createGraph, wireWorkflow as coreWireWorkflow } from '@pikku/core'
+import type { WorkflowMap, GraphsMap } from '${workflowMapImportPath}'
 
-// ============================================================================
-// DSL Workflow Types (pikkuWorkflowFunc, pikkuWorkflowComplexFunc)
-// ============================================================================
+export { template }
 
-/**
- * Typed workflow wire with RPC awareness
- * Provides type-safe workflow.do() for RPC steps
- */
 export interface TypedWorkflow extends PikkuWorkflowWire {
   do<K extends keyof RPCMap>(
     stepName: string,
@@ -41,17 +36,11 @@ export interface TypedWorkflow extends PikkuWorkflowWire {
   ): Promise<T>
 }
 
-/**
- * Workflow function type with typed workflow service
- */
 export type PikkuFunctionWorkflow<
   In = unknown,
   Out = never
 > = PikkuFunctionSessionless<In, Out, 'workflow'>
 
-/**
- * Creates a DSL-compatible workflow function (serializable, shows in Forge UI)
- */
 export const pikkuWorkflowFunc = <In, Out = unknown>(
   func:
     | PikkuFunctionWorkflow<In, Out>
@@ -60,9 +49,6 @@ export const pikkuWorkflowFunc = <In, Out = unknown>(
   return typeof func === 'function' ? { func } : func
 }
 
-/**
- * Creates a complex workflow function (arbitrary code, hidden from Forge UI)
- */
 export const pikkuWorkflowComplexFunc = <In, Out = unknown>(
   func:
     | PikkuFunctionWorkflow<In, Out>
@@ -71,140 +57,8 @@ export const pikkuWorkflowComplexFunc = <In, Out = unknown>(
   return typeof func === 'function' ? { func } : func
 }
 
-// ============================================================================
-// Graph Workflow Types (pikkuWorkflowGraph)
-// ============================================================================
-
-/**
- * Type-safe graph builder with full RPC autocomplete
- */
-const graphBuilder = createGraph<FlattenedRPCMap>()
-
-/** HTTP wire configuration for graph workflows */
-interface GraphHttpWire<NodeIds extends string> {
-  route: string
-  method: HTTPMethod
-  startNode: NodeIds
-}
-
-/** Channel wire configuration for graph workflows */
-interface GraphChannelWire<NodeIds extends string> {
-  name: string
-  onConnect?: NodeIds
-  onDisconnect?: NodeIds
-  onMessage?: NodeIds
-}
-
-/** Queue wire configuration for graph workflows */
-interface GraphQueueWire<NodeIds extends string> {
-  name: string
-  startNode: NodeIds
-}
-
-/** CLI wire configuration for graph workflows */
-interface GraphCliWire<NodeIds extends string> {
-  command: string
-  startNode: NodeIds
-}
-
-/** MCP wire configurations for graph workflows */
-interface GraphMcpWires<NodeIds extends string> {
-  tool?: Array<{ name: string; startNode: NodeIds }>
-  prompt?: Array<{ name: string; startNode: NodeIds }>
-  resource?: Array<{ uri: string; startNode: NodeIds }>
-}
-
-/** Schedule wire configuration for graph workflows */
-interface GraphScheduleWire<NodeIds extends string> {
-  cron?: string
-  interval?: string
-  startNode: NodeIds
-}
-
-/** Trigger wire configuration for graph workflows */
-interface GraphTriggerWire<NodeIds extends string> {
-  name: string  // RPC name of the trigger function
-  startNode: NodeIds
-}
-
-/** All wire configurations for graph workflows */
-interface GraphWiresConfig<NodeIds extends string> {
-  http?: Array<GraphHttpWire<NodeIds>>
-  channel?: Array<GraphChannelWire<NodeIds>>
-  queue?: Array<GraphQueueWire<NodeIds>>
-  cli?: Array<GraphCliWire<NodeIds>>
-  mcp?: GraphMcpWires<NodeIds>
-  schedule?: Array<GraphScheduleWire<NodeIds>>
-  trigger?: Array<GraphTriggerWire<NodeIds>>
-}
-
-/** Configuration for graph-based workflow */
-export interface PikkuWorkflowGraphConfig<
-  FuncMap extends Record<string, keyof FlattenedRPCMap & string>,
-  T
-> {
-  /** Workflow name (optional - defaults to exported variable name) */
-  name?: string
-  /** Optional description */
-  description?: string
-  /** Optional tags for organization */
-  tags?: string[]
-  /** Node to RPC function mapping */
-  nodes: FuncMap
-  /** Wire configurations - how this workflow can be triggered */
-  wires?: GraphWiresConfig<Extract<keyof FuncMap, string>>
-  /** Node configurations (next, input, onError) */
-  config?: T
-}
-
-/** Result of pikkuWorkflowGraph - includes metadata for wiring */
-export interface PikkuWorkflowGraphResult<T, NodeIds extends string = string> {
-  __type: 'pikkuWorkflowGraph'
-  name?: string
-  description?: string
-  tags?: string[]
-  wires?: GraphWiresConfig<NodeIds>
-  graph: T
-}
-
-/**
- * Creates a graph-based workflow definition with metadata
- * Name defaults to the exported variable name if not provided.
- *
- * @example
- * // Name inferred from exported variable name
- * export const myWorkflow = pikkuWorkflowGraph({
- *   description: 'Handles user onboarding',
- *   tags: ['onboarding'],
- *   nodes: {
- *     entry: 'createUser',
- *     sendEmail: 'sendWelcomeEmail',
- *   },
- *   config: {
- *     entry: { next: 'sendEmail' },
- *     sendEmail: { input: (ref) => ({ to: ref('entry', 'email') }) },
- *   },
- * })
- */
-export function pikkuWorkflowGraph<
-  const FuncMap extends Record<string, keyof FlattenedRPCMap & string>
->(
-  config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>
-): PikkuWorkflowGraphResult<Record<Extract<keyof FuncMap, string>, GraphNodeConfig<Extract<keyof FuncMap, string>>>, Extract<keyof FuncMap, string>> {
-  return {
-    __type: 'pikkuWorkflowGraph',
-    name: config.name,
-    description: config.description,
-    tags: config.tags,
-    wires: config.wires,
-    graph: graphBuilder(config.nodes, config.config as any),
-  }
-}
-
-/** Typed ref value */
 type TypedRef<T> = { $ref: string; path?: string } & { __phantomType?: T }
 
-/** Template string type - assignable to string fields */
 type TemplateString = {
   $template: {
     parts: string[]
@@ -212,62 +66,15 @@ type TemplateString = {
   }
 } & { __brand: 'TemplateString' }
 
-/**
- * Creates a template string with variable interpolation
- * Uses indexed placeholders $0, $1, etc. with refs array
- *
- * @example
- * template('Hello $0, your order $1 is ready', [ref('trigger', 'name'), ref('step_0', 'orderId')])
- */
-export function template(templateStr: string, refs: TypedRef<unknown>[]): TemplateString {
-  const parts: string[] = []
-  const expressions: Array<{ $ref: string; path?: string }> = []
-
-  // Parse template string: "Hello $0" -> parts: ["Hello ", ""], use refs[0] for expression
-  const regex = /\$(\d+)/g
-  let lastIndex = 0
-  let match
-
-  while ((match = regex.exec(templateStr)) !== null) {
-    // Add the part before this match
-    parts.push(templateStr.slice(lastIndex, match.index))
-
-    // Get the ref by index
-    const refIndex = parseInt(match[1]!, 10)
-    const refValue = refs[refIndex]
-    if (refValue) {
-      const expr: { $ref: string; path?: string } = { $ref: refValue.$ref }
-      if (refValue.path) {
-        expr.path = refValue.path
-      }
-      expressions.push(expr)
-    } else {
-      expressions.push({ $ref: 'unknown' })
-    }
-
-    lastIndex = regex.lastIndex
-  }
-
-  // Add the remaining part
-  parts.push(templateStr.slice(lastIndex))
-
-  return {
-    $template: { parts, expressions }
-  } as TemplateString
-}
-
-/** Map input type fields to allow TypedRef or TemplateString for any field */
 type InputWithRefs<T> = {
   [K in keyof T]?: T[K] | TypedRef<T[K]> | TypedRef<unknown> | TemplateString
 }
 
-/** Get the input type for a node based on its RPC mapping */
 type NodeInputType<FuncMap extends Record<string, string>, K extends keyof FuncMap> =
   FuncMap[K] extends keyof FlattenedRPCMap
     ? InputWithRefs<FlattenedRPCMap[FuncMap[K]]['input']>
     : Record<string, unknown>
 
-/** Get the output type keys for a node based on its RPC mapping */
 type NodeOutputKeys<FuncMap extends Record<string, string>, N extends string> =
   N extends keyof FuncMap
     ? FuncMap[N] extends keyof FlattenedRPCMap
@@ -275,7 +82,6 @@ type NodeOutputKeys<FuncMap extends Record<string, string>, N extends string> =
       : string
     : string
 
-/** Ref function type with path validation */
 type RefFunction<FuncMap extends Record<string, string>> = {
   <N extends Extract<keyof FuncMap, string>>(
     nodeId: N,
@@ -284,10 +90,8 @@ type RefFunction<FuncMap extends Record<string, string>> = {
   (nodeId: 'trigger' | '$item', path?: string): TypedRef<unknown>
 }
 
-/** Template function type */
 type TemplateFunction = (templateStr: string, refs: TypedRef<unknown>[]) => TemplateString
 
-/** Type helper for node configuration */
 type GraphNodeConfigMap<FuncMap extends Record<string, string>> = {
   [K in Extract<keyof FuncMap, string>]?: {
     next?: NextConfig<Extract<keyof FuncMap, string>>
@@ -301,54 +105,54 @@ type GraphNodeConfigMap<FuncMap extends Record<string, string>> = {
 
 type NextConfig<NodeIds extends string> = NodeIds | NodeIds[] | { if: string; then: NodeIds; else?: NodeIds }
 
-// ============================================================================
-// Unified wireWorkflow
-// ============================================================================
+export function pikkuWorkflowGraph<
+  const FuncMap extends Record<string, keyof FlattenedRPCMap & string>
+>(
+  config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>
+): PikkuWorkflowGraphResult {
+  return corePikkuWorkflowGraph(config as any)
+}
 
-/** Workflow definition with DSL function */
-interface WorkflowDefinitionFunc {
-  /** Whether this workflow wiring is enabled (default: true) */
-  enabled?: boolean
-  /** Wire configurations for the workflow */
-  wires: {
-    http?: { route: string; method: HTTPMethod }
-    channel?: string
-    queue?: string
-  }
-  /** DSL workflow function */
-  func: PikkuFunctionConfig<any, any, 'workflow', PikkuFunctionWorkflow<any, any>>
+export const workflow = <Name extends keyof WorkflowMap>(
+  workflowName: Name,
+  options?: { pollIntervalMs?: number }
+) => {
+  return coreWorkflow<WorkflowMap>(workflowName as string & keyof WorkflowMap, options) as PikkuFunctionConfig<
+    WorkflowMap[Name]['input'],
+    WorkflowMap[Name]['output'],
+    'session' | 'rpc'
+  >
+}
+
+export const workflowStart = <Name extends keyof WorkflowMap>(
+  workflowName: Name
+) => {
+  return coreWorkflowStart<WorkflowMap>(workflowName as string & keyof WorkflowMap) as PikkuFunctionConfig<
+    WorkflowMap[Name]['input'],
+    { runId: string },
+    'session' | 'rpc'
+  >
 }
 
-/** Workflow definition with graph */
-interface WorkflowDefinitionGraph<T, NodeIds extends string = string> {
-  /** Whether this workflow wiring is enabled (default: true) */
-  enabled?: boolean
-  /** Graph workflow definition - wires are defined in the graph itself */
-  graph: PikkuWorkflowGraphResult<T, NodeIds>
+export const workflowStatus = <Name extends keyof WorkflowMap>(
+  _workflowName: Name
+) => {
+  return coreWorkflowStatus<WorkflowMap>(_workflowName as string & keyof WorkflowMap) as PikkuFunctionConfig<
+    { runId: string },
+    { id: string; status: 'running' | 'completed' | 'failed' | 'cancelled'; output?: WorkflowMap[Name]['output']; error?: { message?: string } },
+    'session' | 'rpc'
+  >
 }
 
-/**
- * Wire a workflow with wires
- * Accepts either a DSL function (func) or a graph definition (graph)
- *
- * @example
- * // DSL workflow
- * wireWorkflow({
- *   wires: { http: { route: '/start', method: 'post' } },
- *   func: myWorkflowFunc,
- * })
- *
- * @example
- * // Graph workflow - wires are defined in the graph itself
- * wireWorkflow({
- *   enabled: true,  // default: true
- *   graph: myGraphWorkflow,
- * })
- */
-export function wireWorkflow<T extends Record<string, GraphNodeConfig<Extract<keyof T, string>>>, NodeIds extends string = string>(
-  definition: WorkflowDefinitionFunc | WorkflowDefinitionGraph<T, NodeIds>
-): void {
-  coreWireWorkflow(definition as any)
+export const graphStart = <Name extends keyof GraphsMap, Node extends string & keyof GraphsMap[Name]>(
+  graphName: Name,
+  startNode: Node
+) => {
+  return coreGraphStart<GraphsMap>(graphName as string & keyof GraphsMap, startNode as string) as PikkuFunctionConfig<
+    GraphsMap[Name][Node] extends { input: infer I } ? I : never,
+    { runId: string },
+    'session' | 'rpc'
+  >
 }
 `;
 };

package/dist/src/functions/wirings/workflow/serialize-workflow-workers.js

@@ -30,18 +30,18 @@ export const pikkuWorkflowSleeper = pikkuSessionlessFunc<{ runId: string, stepId
   func: async ({ workflowService }, { runId, stepId }) => {
     await workflowService!.executeWorkflowSleepCompleted(runId, stepId)
   },
-  internal: true,
+  remote: true,
 })
 
 export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<{ rpcName: string, data?: any }, any>({
   func: async (_services, { rpcName, data }, { rpc }) => {
     return await (rpc.invoke as any)(rpcName, data)
   },
-  internal: true,
+  remote: true,
 })
 
-wireQueueWorker({ queueName: 'pikku-workflow-step-worker', func: pikkuWorkflowWorker })
-wireQueueWorker({ queueName: 'pikku-workflow-orchestrator', func: pikkuWorkflowOrchestrator })
-wireQueueWorker({ queueName: 'pikku-remote-internal-rpc', func: pikkuRemoteInternalRPC })
+wireQueueWorker({ name: 'pikku-workflow-step-worker', func: pikkuWorkflowWorker })
+wireQueueWorker({ name: 'pikku-workflow-orchestrator', func: pikkuWorkflowOrchestrator })
+wireQueueWorker({ name: 'pikku-remote-internal-rpc', func: pikkuRemoteInternalRPC })
 `;
 };

package/dist/src/services/cli-logger-forwarder.service.d.ts

@@ -1,6 +1,7 @@
-import { Logger, LogLevel } from '@pikku/core';
-import { PikkuChannel } from '@pikku/core/channel';
-import { ErrorCode } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+import { LogLevel } from '@pikku/core/services';
+import type { PikkuChannel } from '@pikku/core/channel';
+import type { ErrorCode } from '@pikku/inspector';
 /**
  * Log message structure sent through the channel
  */

package/dist/src/services/cli-logger-forwarder.service.js

@@ -1,4 +1,4 @@
-import { LogLevel } from '@pikku/core';
+import { LogLevel } from '@pikku/core/services';
 /**
  * A logger implementation that forwards log messages to a CLI channel
  * instead of logging to console directly.

package/dist/src/services/cli-logger.service.d.ts

@@ -1,5 +1,6 @@
-import { Logger, LogLevel } from '@pikku/core';
-import { ErrorCode } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+import { LogLevel } from '@pikku/core/services';
+import type { ErrorCode } from '@pikku/inspector';
 export declare class CLILogger implements Logger {
     private silent;
     private level;

package/dist/src/services/cli-logger.service.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { LogLevel } from '@pikku/core';
+import { LogLevel } from '@pikku/core/services';
 const logo = `
  ______ _ _     _
 (_____ (_) |   | |

package/dist/src/services.d.ts

@@ -1,11 +1,12 @@
 import type { Config, Services, SingletonServices, UserSession } from '../types/application-types.js';
-import { CreateConfig, CreateWireServices, CreateSingletonServices } from '@pikku/core';
-import { PikkuCLIConfig } from '../types/config.js';
-import { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
+import type { CreateConfig } from '@pikku/core';
+import type { CreateWireServices, CreateSingletonServices } from '@pikku/core/internal';
+import type { PikkuCLIConfig } from '../types/config.js';
+import type { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
 /**
  * Default CLI renderer that logs output using the logger
  */
-export declare const defaultCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, SingletonServices, import("@pikku/core").CoreUserSession>;
+export declare const defaultCLIRenderer: import("@pikku/core/cli").CorePikkuCLIRender<ForwardedLogMessage, SingletonServices, import("@pikku/core").CoreUserSession>;
 export declare const createConfig: CreateConfig<Config, [PikkuCLIConfig]>;
 /**
  * Singleton services factory for the Pikku CLI

package/dist/src/services.js

@@ -1,14 +1,30 @@
 import { pikkuCLIRender } from '@pikku/core/cli';
-import { LocalVariablesService, LocalSecretService, LogLevel, } from '@pikku/core/services';
+import { LocalVariablesService, LocalSecretService, LogLevel, InMemoryWorkflowService, } from '@pikku/core/services';
 import { CLILogger } from './services/cli-logger.service.js';
 import { getPikkuCLIConfig } from './utils/pikku-cli-config.js';
-import { inspect, serializeInspectorState, deserializeInspectorState, filterInspectorState, getInitialInspectorState, } from '@pikku/inspector';
+import { inspect, serializeInspectorState, deserializeInspectorState, filterInspectorState, getInitialInspectorState, ErrorCode, } from '@pikku/inspector';
 import { glob } from 'tinyglobby';
 import path from 'path';
-import { CLILoggerForwarder, } from './services/cli-logger-forwarder.service.js';
+import { CLILoggerForwarder } from './services/cli-logger-forwarder.service.js';
 import { readFile, writeFile } from 'fs/promises';
-// Logger instance will be configured with log level from CLI flags in createConfig
-// Logo will be displayed conditionally in createConfig based on --silent flag
+import { loadManifest } from './utils/contract-versions.js';
+import { join } from 'path';
+const DIAGNOSTIC_CODE_TO_LINT_KEY = {
+    [ErrorCode.SERVICES_NOT_DESTRUCTURED]: 'servicesNotDestructured',
+    [ErrorCode.WIRES_NOT_DESTRUCTURED]: 'wiresNotDestructured',
+};
+function processDiagnostics(diagnostics, lint) {
+    for (const diagnostic of diagnostics) {
+        const lintKey = DIAGNOSTIC_CODE_TO_LINT_KEY[diagnostic.code];
+        const severity = lintKey ? (lint?.[lintKey] ?? 'off') : 'off';
+        if (severity === 'error') {
+            logger.critical(diagnostic.code, diagnostic.message);
+        }
+        else if (severity === 'warn') {
+            logger.warn(`[${diagnostic.code}] ${diagnostic.message}`);
+        }
+    }
+}
 const logger = new CLILogger({ logLogo: false, silent: false });
 /**
  * Parse a comma-separated string or array into an array of trimmed, non-empty strings
@@ -130,6 +146,7 @@ export const createConfig = async (_variablesService, data) => {
     return {
         ...cliConfig,
         ...data,
+        tags: cliConfig.tags,
         filters: parseCLIFilters(data),
         preloadedInspectorState,
     };
@@ -185,17 +202,44 @@ export const createSingletonServices = async (config) => {
                 ignore: config.ignoreFiles || [],
                 absolute: true,
             })))).flat();
-            unfilteredState = inspect(logger, wiringFiles, {
+            const manifest = !setupOnly
+                ? ((await loadManifest(join(config.outDir, 'versions.json'))) ??
+                    undefined)
+                : undefined;
+            unfilteredState = await inspect(logger, wiringFiles, {
                 setupOnly,
                 rootDir,
+                isAddon: config.addon,
                 types: {
                     configFileType: config.configFile,
                     userSessionType: config.userSessionType,
                     singletonServicesFactoryType: config.singletonServicesFactoryType,
                     wireServicesFactoryType: config.wireServicesFactoryType,
                 },
+                tags: config.tags,
+                schemaConfig: !setupOnly
+                    ? {
+                        tsconfig: config.tsconfig,
+                        schemasFromTypes: config.schemasFromTypes,
+                        schema: config.schema,
+                    }
+                    : undefined,
+                openAPI: !setupOnly && config.openAPI
+                    ? { additionalInfo: config.openAPI.additionalInfo }
+                    : undefined,
+                manifest,
+                modelConfig: config.models || config.agentDefaults || config.agentOverrides
+                    ? {
+                        models: config.models,
+                        agentDefaults: config.agentDefaults,
+                        agentOverrides: config.agentOverrides,
+                    }
+                    : undefined,
             });
-            // Save unfiltered inspector state to file if stateOutput is provided
+            if ('diagnostics' in unfilteredState &&
+                unfilteredState.diagnostics.length > 0) {
+                processDiagnostics(unfilteredState.diagnostics, config.lint);
+            }
             if (stateOutput && 'typesLookup' in unfilteredState) {
                 try {
                     logger.info(`Saving inspector state to ${stateOutput}`);
@@ -213,12 +257,14 @@ export const createSingletonServices = async (config) => {
         const filteredState = filterInspectorState(unfilteredState, filters, logger);
         return filteredState;
     };
+    const workflowService = new InMemoryWorkflowService();
     return {
         config,
         logger,
         variables,
         secrets: new LocalSecretService(variables),
         getInspectorState,
+        workflowService,
     };
 };
 export const createWireServices = async ({ logger }, { cli, channel }) => {

package/dist/src/utils/check-required-types.d.ts

@@ -1,4 +1,4 @@
-import { FilesAndMethodsErrors } from '@pikku/inspector';
+import type { FilesAndMethodsErrors } from '@pikku/inspector';
 export type RequiredTypes = Partial<{
     config: boolean;
     wireServiceType: boolean;

package/dist/src/utils/command-summary.d.ts

@@ -3,11 +3,12 @@ export interface CommandSummaryStats {
     channels?: number;
     functions?: number;
     scheduledTasks?: number;
+    triggers?: number;
     queueWorkers?: number;
     mcpEndpoints?: number;
     cliCommands?: number;
     workflows?: number;
-    forgeNodes?: number;
+    nodes?: number;
     workflowGraphs?: number;
     [key: string]: number | undefined;
 }

package/dist/src/utils/command-summary.js

@@ -48,11 +48,12 @@ export class CommandSummary {
             channels: 'WebSocket channel',
             functions: 'Function',
             scheduledTasks: 'Scheduled task',
+            triggers: 'Trigger',
             queueWorkers: 'Queue worker',
             mcpEndpoints: 'MCP endpoint',
             cliCommands: 'CLI command',
             workflows: 'Workflow',
-            forgeNodes: 'Forge node',
+            nodes: 'Node',
             workflowGraphs: 'Workflow graph',
         };
         for (const [key, label] of Object.entries(statLabels)) {

package/dist/src/utils/contract-versions.d.ts

@@ -0,0 +1,6 @@
+import type { VersionManifest } from '@pikku/inspector';
+import { createEmptyManifest } from '@pikku/inspector';
+export { createEmptyManifest };
+export type { ContractEntry, VersionHashEntry, VersionValidateError, VersionManifest, VersionManifestEntry, } from '@pikku/inspector';
+export declare function loadManifest(manifestPath: string): Promise<VersionManifest | null>;
+export declare function saveManifest(manifestPath: string, manifest: VersionManifest): Promise<void>;

package/dist/src/utils/contract-versions.js

@@ -0,0 +1,25 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { dirname } from 'path';
+import { serializeManifest, createEmptyManifest } from '@pikku/inspector';
+export { createEmptyManifest };
+export async function loadManifest(manifestPath) {
+    try {
+        const content = await readFile(manifestPath, 'utf-8');
+        const manifest = JSON.parse(content);
+        if (manifest.manifestVersion !== 1) {
+            throw new Error(`Unsupported manifest version: ${manifest.manifestVersion}`);
+        }
+        return manifest;
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function saveManifest(manifestPath, manifest) {
+    await mkdir(dirname(manifestPath), { recursive: true });
+    await writeFile(manifestPath, serializeManifest(manifest), 'utf-8');
+}