@pikku/cli 0.11.3 → 0.12.1

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.js

@@ -1,18 +1,35 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeTypedRPCMap = (relativeToPath, packageMappings, typesMap, functionsMeta, rpcMeta, externalPackages) => {
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeTypedRPCMap = (logger, relativeToPath, packageMappings, typesMap, rpcMeta, resolvedIOTypes, wireAddonDeclarations, workflowMapPath, agentMapPath) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedRPCs = generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    const externalPackageImports = generateExternalPackageImports(externalPackages, relativeToPath);
-    const mergedRPCMap = generateMergedRPCMap(externalPackages);
+    const serializedRPCs = generateRPCs(rpcMeta, resolvedIOTypes, requiredTypes);
+    const mcpTypes = [
+        'MCPResourceResponse',
+        'MCPToolResponse',
+        'MCPPromptResponse',
+    ];
+    const usedMcpTypes = mcpTypes.filter((t) => requiredTypes.has(t));
+    const mcpImport = usedMcpTypes.length > 0
+        ? `import type { ${usedMcpTypes.join(', ')} } from '@pikku/core/mcp'`
+        : '';
+    for (const t of usedMcpTypes) {
+        requiredTypes.delete(t);
+    }
+    const serializedImportMap = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedCustomTypesDeclarationsOnly = serializedCustomTypes
+        .split('\n')
+        .filter((line) => !line.startsWith('import '))
+        .join('\n');
+    const addonImports = generateAddonImports(wireAddonDeclarations, relativeToPath);
+    const mergedRPCMap = generateMergedRPCMap(wireAddonDeclarations);
     return `/**
  * This provides the structure needed for typescript to be aware of RPCs and their return types
  */
 
+${mcpImport}
 ${serializedImportMap}
-${serializedCustomTypes}
+${serializedCustomTypesDeclarationsOnly}
 
 interface RPCHandler<I, O> {
     input: I;
@@ -20,48 +37,73 @@ interface RPCHandler<I, O> {
 }
 
 ${serializedRPCs}
-${externalPackageImports}
+${addonImports}
 ${mergedRPCMap}
 
 export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
   name: Name,
-  data: FlattenedRPCMap[Name]['input'],
-  options?: {
-    location?: 'local' | 'remote' | 'auto'
-  }
+  data: FlattenedRPCMap[Name]['input']
+) => Promise<FlattenedRPCMap[Name]['output']>
+
+export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
+  name: Name,
+  data: FlattenedRPCMap[Name]['input']
 ) => Promise<FlattenedRPCMap[Name]['output']>
 
-// Import WorkflowMap for workflow typing
-import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
+${workflowMapPath ? `import type { WorkflowMap } from '${workflowMapPath}'` : `type WorkflowMap = {}`}
+
+${agentMapPath ? `import type { AgentMap } from '${agentMapPath}'` : `type AgentMap = {}`}
+${generateAddonAgentImports(wireAddonDeclarations)}
+${generateMergedAgentMap(wireAddonDeclarations)}
+
+import type { PikkuRPC } from '@pikku/core/rpc'
 
-export type TypedPikkuRPC = {
-  depth: number;
-  global: boolean;
-  invoke: RPCInvoke;
-  invokeExposed: (name: string, data: any) => Promise<any>;
-  startWorkflow: <Name extends keyof WorkflowMap>(
-    name: Name,
-    input: WorkflowMap[Name]['input']
-  ) => Promise<{ runId: string }>;
+interface AIAgentInput {
+  message: string
+  threadId: string
+  resourceId: string
 }
+
+export type TypedStartWorkflow = <Name extends keyof WorkflowMap>(
+  name: Name,
+  input: WorkflowMap[Name]['input'],
+  options?: { startNode?: string }
+) => Promise<{ runId: string }>
+
+type TypedAgentRun = [keyof FlattenedAgentMap] extends [never]
+  ? (name: string, input: AIAgentInput) => Promise<any>
+  : <Name extends keyof FlattenedAgentMap>(
+      name: Name,
+      input: AIAgentInput
+    ) => Promise<{ runId: string; result: FlattenedAgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } }>
+
+type TypedAgentStream = [keyof FlattenedAgentMap] extends [never]
+  ? (name: string, input: AIAgentInput, options?: { requiresToolApproval?: 'all' | 'explicit' | false }) => Promise<void>
+  : <Name extends keyof FlattenedAgentMap>(
+      name: Name,
+      input: AIAgentInput,
+      options?: { requiresToolApproval?: 'all' | 'explicit' | false }
+    ) => Promise<void>
+
+export type TypedPikkuRPC = PikkuRPC<RPCInvoke, RPCRemote, TypedStartWorkflow, TypedAgentRun, TypedAgentStream>
   `;
 };
-function generateExternalPackageImports(externalPackages, relativeToPath) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateAddonImports(wireAddonDeclarations, relativeToPath) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return '';
     }
-    let imports = '\n// External package RPC maps\n';
-    for (const [namespace, packageName] of Object.entries(externalPackages)) {
-        // Import the RPCMap from each external package's internal RPC map
+    let imports = '\n// Addon package RPC maps\n';
+    for (const [namespace, decl] of wireAddonDeclarations.entries()) {
+        // Import the RPCMap from each addon package's internal RPC map
         // Use .js extension - package.json exports will resolve to .d.ts for types
-        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${packageName}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
+        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${decl.package}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
     }
     return imports;
 }
-function generateMergedRPCMap(externalPackages) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateMergedRPCMap(wireAddonDeclarations) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return `
-// No external packages, use RPCMap directly
+// No addon packages, use RPCMap directly
 export type FlattenedRPCMap = RPCMap
 `;
     }
@@ -74,7 +116,7 @@ type PrefixKeys<T, Prefix extends string> = {
 
 // Merge all RPC maps with namespace prefixes
 export type FlattenedRPCMap =
-  RPCMap${Object.keys(externalPackages)
+  RPCMap${Array.from(wireAddonDeclarations.keys())
         .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`)
         .join('')}
 `;
@@ -86,46 +128,39 @@ function toPascalCase(str) {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
         .join('');
 }
-function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect RPCs
+function generateAddonAgentImports(wireAddonDeclarations) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
+        return '';
+    }
+    let imports = '\n// Addon package Agent maps\n';
+    for (const [namespace, decl] of wireAddonDeclarations.entries()) {
+        imports += `import type { AgentMap as ${toPascalCase(namespace)}AgentMap } from '${decl.package}/.pikku/agent/pikku-agent-map.gen.d.js'\n`;
+    }
+    return imports;
+}
+function generateMergedAgentMap(wireAddonDeclarations) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
+        return `
+type FlattenedAgentMap = AgentMap
+`;
+    }
+    return `
+type FlattenedAgentMap =
+  AgentMap${Array.from(wireAddonDeclarations.keys())
+        .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}AgentMap, '${namespace}'>`)
+        .join('')}
+`;
+}
+function generateRPCs(rpcMeta, resolvedIOTypes, requiredTypes) {
     const rpcsObj = {};
-    // Iterate through RPC metadata
-    for (const [funcName, pikkuFuncName] of Object.entries(rpcMeta)) {
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${funcName} not found in functionsMeta. Please check your configuration.`);
-        }
-        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        // Store the input and output types for RPCHandler
-        // For zod-derived schemas, the type might not be in typesMap, so use the schema name directly
-        let inputType = 'null';
-        if (input) {
-            try {
-                inputType = typesMap.getTypeMeta(input).uniqueName;
-            }
-            catch {
-                // Type not in typesMap - use the name directly (e.g., zod-derived types)
-                inputType = input;
-            }
-        }
-        let outputType = 'null';
-        if (output) {
-            try {
-                outputType = typesMap.getTypeMeta(output).uniqueName;
-            }
-            catch {
-                // Type not in typesMap - use the name directly (e.g., zod-derived types)
-                outputType = output;
-            }
+    for (const [funcName, pikkuFuncId] of Object.entries(rpcMeta)) {
+        const resolved = resolvedIOTypes[pikkuFuncId];
+        if (!resolved) {
+            throw new Error(`Function ${pikkuFuncId} not found in resolvedIOTypes. Please check your configuration.`);
         }
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add RPC entry
-        rpcsObj[funcName] = {
-            inputType,
-            outputType,
-        };
+        requiredTypes.add(resolved.inputType);
+        requiredTypes.add(resolved.outputType);
+        rpcsObj[funcName] = resolved;
     }
     // Build the RPCs object as a string
     let rpcsStr = 'export type RPCMap = {\n';

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler-types.d.ts

@@ -1 +1 @@
-export declare const pikkuSchedulerTypes: any;
+export declare const pikkuSchedulerTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler-types.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler.d.ts

@@ -1 +1 @@
-export declare const pikkuScheduler: any;
+export declare const pikkuScheduler: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/scheduler/serialize-scheduler-meta.d.ts

@@ -1,3 +1,3 @@
-import { ScheduledTasksMeta } from '@pikku/core/scheduler';
+import type { ScheduledTasksMeta } from '@pikku/core/scheduler';
 export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => ScheduledTasksMeta;
-export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: any) => string;
+export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;

package/dist/src/functions/wirings/scheduler/serialize-scheduler-meta.js

@@ -1,20 +1,21 @@
+import { serializeMetaTS } from '../../../utils/serialize-meta-ts.js';
 export const serializeSchedulerMeta = (scheduledTasksMeta) => {
     return scheduledTasksMeta;
 };
 export const serializeSchedulerMetaTS = (scheduledTasksMeta, jsonImportPath, supportsImportAttributes) => {
-    const importStatement = supportsImportAttributes
-        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-        : `import metaData from '${jsonImportPath}'`;
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push("import { ScheduledTasksMeta } from '@pikku/core/scheduler'");
-    serializedOutput.push(importStatement);
-    serializedOutput.push('');
-    serializedOutput.push("pikkuState(null, 'scheduler', 'meta', metaData as ScheduledTasksMeta)");
-    serializedOutput.push('');
+    const base = serializeMetaTS({
+        jsonImportPath,
+        supportsImportAttributes,
+        pikkuStateNamespace: 'scheduler',
+        pikkuStateKey: 'meta',
+        metaTypeImport: '@pikku/core/scheduler',
+        metaTypeName: 'ScheduledTasksMeta',
+    });
     const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
     if (scheduledTasksMetaValues.length > 0) {
-        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
+        return (base +
+            '\n\n' +
+            `export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
     }
-    return serializedOutput.join('\n');
+    return base;
 };

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

@@ -22,7 +22,7 @@ type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'sessio
  * @param task - Scheduled task definition with cron expression and handler
  */
 export const wireScheduler = (task: SchedulerWiring) => {
-  wireSchedulerCore(task as any) // TODO
+  wireSchedulerCore(task as any)
 }
 `;
 };

package/dist/src/functions/wirings/secrets/pikku-command-secrets.d.ts

@@ -0,0 +1 @@
+export declare const pikkuSecrets: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/secrets/pikku-command-secrets.js

@@ -0,0 +1,31 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeSecretsTypes } from './serialize-secrets-types.js';
+import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
+export const pikkuSecrets = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { secretsFile, secretsMetaJsonFile, packageMappings } = config;
+        if (!secretsFile) {
+            return;
+        }
+        const state = await getInspectorState();
+        const content = serializeSecretsTypes({
+            definitions: state.secrets.definitions,
+            schemaLookup: state.schemaLookup,
+            secretsFile,
+            packageMappings,
+        });
+        await writeFileInDir(logger, secretsFile, content);
+        if (secretsMetaJsonFile) {
+            const meta = validateAndBuildSecretDefinitionsMeta(state.secrets.definitions, state.schemaLookup);
+            await writeFileInDir(logger, secretsMetaJsonFile, JSON.stringify(meta, null, 2));
+        }
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating PikkuSecrets types',
+            commandEnd: 'Created PikkuSecrets types',
+        }),
+    ],
+});

package/dist/src/functions/wirings/secrets/serialize-secrets-types.d.ts

@@ -0,0 +1,9 @@
+import type { SecretDefinitions } from '@pikku/core/secret';
+import type { SchemaRef } from '@pikku/inspector';
+export interface SerializeSecretsOptions {
+    definitions: SecretDefinitions;
+    schemaLookup: Map<string, SchemaRef>;
+    secretsFile: string;
+    packageMappings: Record<string, string>;
+}
+export declare const serializeSecretsTypes: ({ definitions, schemaLookup, secretsFile, packageMappings, }: SerializeSecretsOptions) => string;

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

@@ -0,0 +1,64 @@
+import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializeSecretsTypes = ({ definitions, schemaLookup, secretsFile, packageMappings, }) => {
+    const secrets = validateAndBuildSecretDefinitionsMeta(definitions, schemaLookup);
+    const credentialEntries = Object.entries(secrets);
+    const schemaImports = new Map();
+    let needsOAuth2Types = false;
+    let needsZod = false;
+    const mapEntries = [];
+    const metaEntries = [];
+    for (const [name, meta] of credentialEntries) {
+        if (meta.oauth2) {
+            needsOAuth2Types = true;
+            mapEntries.push(`  '${meta.secretId}': OAuth2AppCredential`);
+            mapEntries.push(`  '${meta.oauth2.tokenSecretId}': OAuth2Token`);
+            metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: '${meta.displayName}', oauth2: { tokenSecretId: '${meta.oauth2.tokenSecretId}' } }`);
+            metaEntries.push(`  '${meta.oauth2.tokenSecretId}': { name: '${name}_tokens', displayName: '${meta.displayName} Tokens' }`);
+        }
+        else if (meta.schema && typeof meta.schema === 'string') {
+            const schemaRef = schemaLookup.get(meta.schema);
+            if (schemaRef) {
+                needsZod = true;
+                if (!schemaImports.has(schemaRef.sourceFile)) {
+                    schemaImports.set(schemaRef.sourceFile, new Set());
+                }
+                schemaImports.get(schemaRef.sourceFile).add(schemaRef.variableName);
+                mapEntries.push(`  '${meta.secretId}': z.infer<typeof ${schemaRef.variableName}>`);
+                metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: '${meta.displayName}' }`);
+            }
+        }
+    }
+    const imports = [];
+    imports.push(`import { TypedSecretService as CoreTypedSecretService, type CredentialMeta } from '@pikku/core/services'`);
+    imports.push(`import type { SecretService } from '@pikku/core/services'`);
+    if (needsZod) {
+        imports.push(`import type { z } from 'zod'`);
+    }
+    if (needsOAuth2Types) {
+        imports.push(`import type { OAuth2AppCredential, OAuth2Token } from '@pikku/core/oauth2'`);
+    }
+    for (const [sourceFile, variableNames] of schemaImports) {
+        const importPath = getFileImportRelativePath(secretsFile, sourceFile, packageMappings);
+        const vars = Array.from(variableNames).join(', ');
+        imports.push(`import { ${vars} } from '${importPath}'`);
+    }
+    return `${imports.join('\n')}
+
+export interface CredentialsMap {
+${mapEntries.join('\n')}
+}
+
+export type SecretId = keyof CredentialsMap
+
+const CREDENTIALS_META: Record<string, CredentialMeta> = {
+${metaEntries.join(',\n')}
+}
+
+export class TypedSecretService extends CoreTypedSecretService<CredentialsMap> {
+  constructor(secrets: SecretService) {
+    super(secrets, CREDENTIALS_META)
+  }
+}
+`;
+};

package/dist/src/functions/wirings/triggers/pikku-command-trigger-types.d.ts

@@ -0,0 +1 @@
+export declare const pikkuTriggerTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/triggers/pikku-command-trigger-types.js

@@ -0,0 +1,24 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeTriggerTypes } from './serialize-trigger-types.js';
+export const pikkuTriggerTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { triggersTypesFile, packageMappings } = config;
+        const visitState = await getInspectorState();
+        const { singletonServicesType } = visitState.filesAndMethods;
+        if (!singletonServicesType) {
+            throw new Error('SingletonServices type not found');
+        }
+        const singletonServicesTypeImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(triggersTypesFile, singletonServicesType.typePath, packageMappings)}'`;
+        const content = serializeTriggerTypes(singletonServicesTypeImport, singletonServicesType.type);
+        await writeFileInDir(logger, triggersTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating trigger types',
+            commandEnd: 'Created trigger types',
+        }),
+    ],
+});

package/dist/src/functions/wirings/triggers/pikku-command-trigger.d.ts

@@ -0,0 +1 @@
+export declare const pikkuTrigger: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/triggers/pikku-command-trigger.js

@@ -0,0 +1,40 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeTriggerMeta, serializeTriggerMetaTS, serializeTriggerSourceMeta, serializeTriggerSourceMetaTS, } from './serialize-trigger-meta.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+export const pikkuTrigger = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { triggersWiringFile, triggersWiringMetaFile, triggersWiringMetaJsonFile, triggerSourcesMetaFile, triggerSourcesMetaJsonFile, packageMappings, schema, } = config;
+        const { triggers } = visitState;
+        if (Object.keys(triggers.meta).length === 0) {
+            return undefined;
+        }
+        const fullMeta = serializeTriggerMeta(triggers.meta);
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(fullMeta);
+        await writeFileInDir(logger, triggersWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(fullMeta)) {
+            const verbosePath = triggersWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
+        }
+        const jsonImportPath = getFileImportRelativePath(triggersWiringMetaFile, triggersWiringMetaJsonFile, packageMappings);
+        await writeFileInDir(logger, triggersWiringMetaFile, serializeTriggerMetaTS(triggers.meta, jsonImportPath, schema?.supportsImportAttributes ?? false));
+        await writeFileInDir(logger, triggersWiringFile, serializeFileImports('wireTrigger', triggersWiringFile, triggers.files, packageMappings));
+        const sourceMetaJson = serializeTriggerSourceMeta(triggers.sourceMeta);
+        await writeFileInDir(logger, triggerSourcesMetaJsonFile, JSON.stringify(sourceMetaJson, null, 2));
+        const sourceMetaJsonImportPath = getFileImportRelativePath(triggerSourcesMetaFile, triggerSourcesMetaJsonFile, packageMappings);
+        await writeFileInDir(logger, triggerSourcesMetaFile, serializeTriggerSourceMetaTS(triggers.sourceMeta, sourceMetaJsonImportPath, schema?.supportsImportAttributes ?? false));
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding triggers',
+            commandEnd: 'Found triggers',
+        }),
+    ],
+});

package/dist/src/functions/wirings/triggers/serialize-trigger-meta.d.ts

@@ -0,0 +1,5 @@
+import type { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger';
+export declare const serializeTriggerMeta: (triggerMeta: TriggerMeta) => TriggerMeta;
+export declare const serializeTriggerMetaTS: (triggerMeta: TriggerMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;
+export declare const serializeTriggerSourceMeta: (sourceMeta: TriggerSourceMeta) => TriggerSourceMeta;
+export declare const serializeTriggerSourceMetaTS: (sourceMeta: TriggerSourceMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;

package/dist/src/functions/wirings/triggers/serialize-trigger-meta.js

@@ -0,0 +1,35 @@
+export const serializeTriggerMeta = (triggerMeta) => {
+    return triggerMeta;
+};
+export const serializeTriggerMetaTS = (triggerMeta, jsonImportPath, supportsImportAttributes) => {
+    const importStatement = supportsImportAttributes
+        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+        : `import metaData from '${jsonImportPath}'`;
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core/internal'");
+    serializedOutput.push("import { TriggerMeta } from '@pikku/core/trigger'");
+    serializedOutput.push(importStatement);
+    serializedOutput.push('');
+    serializedOutput.push("pikkuState(null, 'trigger', 'meta', metaData as TriggerMeta)");
+    serializedOutput.push('');
+    const triggerMetaValues = Object.values(triggerMeta);
+    if (triggerMetaValues.length > 0) {
+        serializedOutput.push(`export type TriggerNames = '${triggerMetaValues.map((t) => t.name).join("' | '")}'`);
+    }
+    return serializedOutput.join('\n');
+};
+export const serializeTriggerSourceMeta = (sourceMeta) => {
+    return sourceMeta;
+};
+export const serializeTriggerSourceMetaTS = (sourceMeta, jsonImportPath, supportsImportAttributes) => {
+    const importStatement = supportsImportAttributes
+        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+        : `import metaData from '${jsonImportPath}'`;
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core/internal'");
+    serializedOutput.push("import { TriggerSourceMeta } from '@pikku/core/trigger'");
+    serializedOutput.push(importStatement);
+    serializedOutput.push('');
+    serializedOutput.push("pikkuState(null, 'trigger', 'sourceMeta', metaData as TriggerSourceMeta)");
+    return serializedOutput.join('\n');
+};

package/dist/src/functions/wirings/triggers/serialize-trigger-types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generates type definitions for trigger wirings
+ */
+export declare const serializeTriggerTypes: (singletonServicesTypeImport: string, singletonServicesTypeName: string) => string;