@pikku/cli 0.11.3 → 0.12.0

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,4 +1,4 @@
-import { Logger, LogLevel } from '@pikku/core';
+import { Logger, LogLevel } from '@pikku/core/services';
 import { PikkuChannel } from '@pikku/core/channel';
 import { ErrorCode } from '@pikku/inspector';
 /**

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,4 +1,4 @@
-import { Logger, LogLevel } from '@pikku/core';
+import { Logger, LogLevel } from '@pikku/core/services';
 import { ErrorCode } from '@pikku/inspector';
 export declare class CLILogger implements Logger {
     private silent;

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

@@ -5,7 +5,7 @@ import { 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 { 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,45 @@ 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,
+                isExternalPackage: config.externalPackage,
                 types: {
                     configFileType: config.configFile,
                     userSessionType: config.userSessionType,
                     singletonServicesFactoryType: config.singletonServicesFactoryType,
                     wireServicesFactoryType: config.wireServicesFactoryType,
                 },
+                tags: config.tags,
+                externalPackages: config.externalPackages,
+                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 +258,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/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, 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');
+}

package/dist/src/utils/file-import-path.js

@@ -4,13 +4,27 @@ export const getFileImportRelativePath = (from, to, packageMappings) => {
     if (!/^\.+\//.test(filePath)) {
         filePath = `./${filePath}`;
     }
-    // If the path includes node_modules, strip everything before and including node_modules/
-    if (filePath.includes('node_modules')) {
-        const nodeModulesIndex = filePath.indexOf('node_modules/');
-        if (nodeModulesIndex !== -1) {
-            filePath = filePath.substring(nodeModulesIndex + 'node_modules/'.length);
+    const posixPath = filePath.replace(/\\/g, '/');
+    if (posixPath.includes('node_modules/')) {
+        const nodeModulesIndex = posixPath.indexOf('node_modules/');
+        filePath = posixPath.substring(nodeModulesIndex + 'node_modules/'.length);
+        if (filePath.startsWith('@types/')) {
+            filePath = filePath.substring('@types/'.length);
+            const parts = filePath.split('/');
+            if (parts[0].includes('__')) {
+                const [scope, name] = parts[0].split('__');
+                parts[0] = `@${scope}/${name}`;
+                filePath = parts.join('/');
+            }
+        }
+        if (filePath.endsWith('.d.ts')) {
+            filePath = filePath.slice(0, -5);
+        }
+        else if (filePath.endsWith('.ts')) {
+            filePath = filePath.slice(0, -3) + '.js';
         }
-        return filePath.replace('.ts', '.js');
+        filePath = filePath.replace(/\/index$/, '').replace(/\/index\.js$/, '');
+        return filePath;
     }
     const absolutePath = resolve(dirname(from), to);
     const fromAbsolutePath = resolve(dirname(from));

package/dist/src/utils/pikku-cli-config.js

@@ -162,6 +162,25 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.rpc.remoteRpcWorkersPath) {
             result.rpc.remoteRpcWorkersPath = join(rpcDir, 'pikku-remote-rpc-workers.gen.ts');
         }
+        const triggerDir = join(result.outDir, 'trigger');
+        if (!result.triggersTypesFile) {
+            result.triggersTypesFile = join(triggerDir, 'pikku-trigger-types.gen.ts');
+        }
+        if (!result.triggersWiringFile) {
+            result.triggersWiringFile = join(triggerDir, 'pikku-trigger-wirings.gen.ts');
+        }
+        if (!result.triggersWiringMetaFile) {
+            result.triggersWiringMetaFile = join(triggerDir, 'pikku-trigger-wirings-meta.gen.ts');
+        }
+        if (!result.triggersWiringMetaJsonFile) {
+            result.triggersWiringMetaJsonFile = join(triggerDir, 'pikku-trigger-wirings-meta.gen.json');
+        }
+        if (!result.triggerSourcesMetaFile) {
+            result.triggerSourcesMetaFile = join(triggerDir, 'pikku-trigger-sources-meta.gen.ts');
+        }
+        if (!result.triggerSourcesMetaJsonFile) {
+            result.triggerSourcesMetaJsonFile = join(triggerDir, 'pikku-trigger-sources-meta.gen.json');
+        }
         // Scheduler
         if (!result.schedulersWiringFile) {
             result.schedulersWiringFile = join(schedulerDir, 'pikku-schedulers-wirings.gen.ts');
@@ -219,9 +238,6 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.middlewareFile) {
             result.middlewareFile = join(middlewareDir, 'pikku-middleware.gen.ts');
         }
-        if (!result.middlewareGroupsMetaFile) {
-            result.middlewareGroupsMetaFile = join(middlewareDir, 'pikku-middleware-groups-meta.gen.ts');
-        }
         if (!result.middlewareGroupsMetaJsonFile) {
             result.middlewareGroupsMetaJsonFile = join(middlewareDir, 'pikku-middleware-groups-meta.gen.json');
         }
@@ -230,14 +246,13 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.permissionsFile) {
             result.permissionsFile = join(permissionsDir, 'pikku-permissions.gen.ts');
         }
+        if (!result.permissionsGroupsMetaJsonFile) {
+            result.permissionsGroupsMetaJsonFile = join(permissionsDir, 'pikku-permissions-groups-meta.gen.json');
+        }
         // Bootstrap files
         if (!result.bootstrapFile) {
             result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts');
         }
-        // Package service factories (for external packages)
-        if (!result.packageFile) {
-            result.packageFile = join(result.outDir, 'pikku-package.gen.ts');
-        }
         // MCP
         if (!result.mcpWiringsMetaFile) {
             result.mcpWiringsMetaFile = join(mcpDir, 'pikku-mcp-wirings-meta.gen.ts');
@@ -254,6 +269,23 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.mcpTypesFile) {
             result.mcpTypesFile = join(mcpDir, 'pikku-mcp-types.gen.ts');
         }
+        // AI Agent
+        const agentDir = join(result.outDir, 'agent');
+        if (!result.agentWiringsFile) {
+            result.agentWiringsFile = join(agentDir, 'pikku-agent-wirings.gen.ts');
+        }
+        if (!result.agentWiringMetaFile) {
+            result.agentWiringMetaFile = join(agentDir, 'pikku-agent-wirings-meta.gen.ts');
+        }
+        if (!result.agentWiringMetaJsonFile) {
+            result.agentWiringMetaJsonFile = join(agentDir, 'pikku-agent-wirings-meta.gen.json');
+        }
+        if (!result.agentTypesFile) {
+            result.agentTypesFile = join(agentDir, 'pikku-agent-types.gen.ts');
+        }
+        if (!result.agentMapDeclarationFile) {
+            result.agentMapDeclarationFile = join(agentDir, 'pikku-agent-map.gen.d.ts');
+        }
         // CLI
         if (!result.cliWiringsFile) {
             result.cliWiringsFile = join(cliDir, 'pikku-cli-wirings.gen.ts');
@@ -270,19 +302,50 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.cliTypesFile) {
             result.cliTypesFile = join(cliDir, 'pikku-cli-types.gen.ts');
         }
-        // Forge
-        const forgeDir = join(result.outDir, 'forge');
-        if (!result.forgeNodesMetaJsonFile) {
-            result.forgeNodesMetaJsonFile = join(forgeDir, 'pikku-forge-nodes-meta.gen.json');
+        const consoleDir = join(result.outDir, 'console');
+        if (!result.nodesMetaJsonFile) {
+            result.nodesMetaJsonFile = join(consoleDir, 'pikku-nodes-meta.gen.json');
+        }
+        if (!result.nodeTypesFile) {
+            result.nodeTypesFile = join(consoleDir, 'pikku-node-types.gen.ts');
+        }
+        // External (for wireSecret, external service factories, and external meta)
+        const externalDir = join(result.outDir, 'external');
+        if (!result.packageFile) {
+            result.packageFile = join(externalDir, 'pikku-package.gen.ts');
+        }
+        if (!result.externalTypesFile) {
+            result.externalTypesFile = join(externalDir, 'pikku-external-types.gen.ts');
+        }
+        // Secrets (typed wrapper for SecretService)
+        const secretsDir = join(result.outDir, 'secrets');
+        if (!result.secretTypesFile) {
+            result.secretTypesFile = join(secretsDir, 'pikku-secret-types.gen.ts');
+        }
+        if (!result.secretsFile) {
+            result.secretsFile = join(secretsDir, 'pikku-secrets.gen.ts');
+        }
+        if (!result.secretsMetaJsonFile) {
+            result.secretsMetaJsonFile = join(secretsDir, 'pikku-secrets-meta.gen.json');
+        }
+        // Variables (typed wrapper for VariablesService)
+        const variablesDir = join(result.outDir, 'variables');
+        if (!result.variableTypesFile) {
+            result.variableTypesFile = join(variablesDir, 'pikku-variable-types.gen.ts');
+        }
+        if (!result.variablesFile) {
+            result.variablesFile = join(variablesDir, 'pikku-variables.gen.ts');
         }
-        if (!result.forgeTypesFile) {
-            result.forgeTypesFile = join(forgeDir, 'pikku-forge-types.gen.ts');
+        if (!result.variablesMetaJsonFile) {
+            result.variablesMetaJsonFile = join(variablesDir, 'pikku-variables-meta.gen.json');
         }
         if (requiredFields.length > 0) {
             validateCLIConfig(result, requiredFields);
         }
         for (const objectKey of Object.keys(result)) {
-            if (objectKey.endsWith('File') || objectKey.endsWith('Directory')) {
+            if (objectKey.endsWith('File') ||
+                objectKey.endsWith('Directory') ||
+                objectKey.endsWith('Dir')) {
                 const relativeTo = CONFIG_DIR_FILES.includes(objectKey)
                     ? result.configDir
                     : result.rootDir;

package/dist/src/utils/pikku-files-and-methods.d.ts

@@ -4,7 +4,6 @@ interface Meta {
     variable: string;
     type: string;
     typePath: string;
-    errors: Map<string, string[]>;
 }
 export type FilesAndMethods = {
     userSessionType: Meta;

package/dist/src/utils/pikku-files-and-methods.js

@@ -1,70 +1,25 @@
-const getMetaTypes = (type, map, desiredType) => {
-    const errors = new Map();
-    if (desiredType) {
-        for (const [file, meta] of map.entries()) {
-            for (const { type: entryType, variable, typePath } of meta) {
-                if (entryType === desiredType) {
-                    if (entryType === null || typePath === null) {
-                        throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${desiredType} in ${file}`);
-                    }
-                    return { file, variable, type: entryType, typePath, errors };
-                }
-            }
-        }
-        errors.set(`No ${desiredType} found that extends ${type}`, map);
-        return;
-    }
-    const totalValues = Array.from(map.values()).flat();
-    if (totalValues.length === 0) {
-        const helpMessage = type === 'CoreConfig'
-            ? `No ${type} found. Make sure you have exported a createConfig function in your codebase:\n\n` +
-                `export const createConfig: CreateConfig<Config> = async () => {\n` +
-                `  return {}\n` +
-                `}\n\n` +
-                `Possible issues:\n` +
-                `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
-            : `No ${type} found`;
-        errors.set(helpMessage, map);
-    }
-    else if (totalValues.length > 1) {
-        errors.set(`More than one ${type} found`, map);
-    }
-    else {
-        const entry = Array.from(map.entries())[0];
-        if (entry) {
-            const [file, [{ type: entryType, variable, typePath }]] = entry;
-            if (entryType === null || typePath === null) {
-                throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${type} in ${file}`);
-            }
-            return { file, type: entryType, variable, typePath, errors };
-        }
-    }
-    return;
-};
+import { getFilesAndMethods, } from '@pikku/inspector';
 /**
  * @deprecated Use state.filesAndMethods from InspectorState instead
  */
 export const getPikkuFilesAndMethods = async (state, options = {}) => {
-    const { singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, } = state;
-    const { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, } = options;
-    let errors = new Map();
-    const result = {
-        userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType),
-        singletonServicesType: getMetaTypes('CoreSingletonServices', singletonServicesTypeImportMap),
-        wireServicesType: getMetaTypes('CoreServices', wireServicesTypeImportMap),
-        pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType),
-        singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType),
-        wireServicesFactory: getMetaTypes('CreateWireServices', wireServicesFactories, wireServicesFactoryType),
-    };
+    const { result: sharedResult, errors } = getFilesAndMethods(state, options);
     if (errors.size > 0) {
-        const result = ['Found errors:'];
+        const messages = ['Found errors:'];
         errors.forEach((filesAndMethods, message) => {
-            result.push(`- ${message}`);
-            filesAndMethods.forEach((methods, file) => {
-                result.push(`\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`);
+            messages.push(`- ${message}`);
+            filesAndMethods.forEach((methods) => {
+                messages.push(`\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`);
             });
         });
-        throw new Error(result.join('\n'));
+        throw new Error(messages.join('\n'));
     }
-    return result;
+    return {
+        userSessionType: sharedResult.userSessionType,
+        singletonServicesType: sharedResult.singletonServicesType,
+        wireServicesType: sharedResult.wireServicesType,
+        pikkuConfigFactory: sharedResult.pikkuConfigFactory,
+        singletonServicesFactory: sharedResult.singletonServicesFactory,
+        wireServicesFactory: sharedResult.wireServicesFactory,
+    };
 };

package/dist/src/utils/serialize-import-map.d.ts

@@ -1,2 +1,3 @@
 import { TypesMap } from '@pikku/inspector';
-export declare const serializeImportMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, requiredTypes: Set<string>) => string;
+import { Logger } from '@pikku/core/services';
+export declare const serializeImportMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, requiredTypes: Set<string>) => string;

package/dist/src/utils/serialize-import-map.js

@@ -1,5 +1,5 @@
 import { getFileImportRelativePath } from './file-import-path.js';
-export const serializeImportMap = (relativeToPath, packageMappings, typesMap, requiredTypes) => {
+export const serializeImportMap = (logger, relativeToPath, packageMappings, typesMap, requiredTypes) => {
     const paths = new Map();
     Array.from(requiredTypes).forEach((requiredType) => {
         let originalName, uniqueName, path;
@@ -10,59 +10,8 @@ export const serializeImportMap = (relativeToPath, packageMappings, typesMap, re
             path = typeMeta.path;
         }
         catch (e) {
-            // Handle missing types by trying to find a suitable import path
-            // Look through all existing types in the map to find a path that might contain this type
-            let foundPath = null;
-            // Get all unique paths from the typesMap
-            const allPaths = new Set();
-            typesMap.customTypes.forEach(({ type, references }) => {
-                references.forEach((ref) => {
-                    try {
-                        const refMeta = typesMap.getTypeMeta(ref);
-                        if (refMeta.path) {
-                            allPaths.add(refMeta.path);
-                        }
-                    }
-                    catch {
-                        // Continue
-                    }
-                });
-            });
-            // Also check direct types in the map
-            try {
-                const mapEntries = typesMap.map?.entries?.() || [];
-                for (const [_, typeMeta] of mapEntries) {
-                    if (typeMeta.path) {
-                        allPaths.add(typeMeta.path);
-                    }
-                }
-            }
-            catch {
-                // Continue
-            }
-            // For PascalCase types, prefer paths that look like type definition files
-            if (/^[A-Z]/.test(requiredType)) {
-                for (const candidatePath of allPaths) {
-                    if (candidatePath.includes('types') ||
-                        candidatePath.includes('.d.')) {
-                        foundPath = candidatePath;
-                        break;
-                    }
-                }
-                // If no types file found, use the first available path
-                if (!foundPath && allPaths.size > 0) {
-                    foundPath = Array.from(allPaths)[0] || null;
-                }
-            }
-            if (foundPath) {
-                originalName = requiredType;
-                uniqueName = requiredType;
-                path = foundPath;
-            }
-            else {
-                // No suitable path found, skip
-                return;
-            }
+            logger.warn(`Type '${requiredType}' not found in typesMap - skipping import`);
+            return;
         }
         if (!path) {
             // This is a custom type that exists in file, so we don't need to import it

package/dist/src/utils/serialize-meta-ts.d.ts

@@ -0,0 +1,8 @@
+export declare function serializeMetaTS({ jsonImportPath, supportsImportAttributes, pikkuStateNamespace, pikkuStateKey, metaTypeImport, metaTypeName, }: {
+    jsonImportPath: string;
+    supportsImportAttributes: boolean;
+    pikkuStateNamespace: string;
+    pikkuStateKey: string;
+    metaTypeImport: string;
+    metaTypeName: string;
+}): string;

package/dist/src/utils/serialize-meta-ts.js

@@ -0,0 +1,12 @@
+export function serializeMetaTS({ jsonImportPath, supportsImportAttributes, pikkuStateNamespace, pikkuStateKey, metaTypeImport, metaTypeName, }) {
+    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 { ${metaTypeName} } from '${metaTypeImport}'`);
+    serializedOutput.push(importStatement);
+    serializedOutput.push('');
+    serializedOutput.push(`pikkuState(null, '${pikkuStateNamespace}', '${pikkuStateKey}', metaData as ${metaTypeName})`);
+    return serializedOutput.join('\n');
+}

package/dist/src/utils/serialize-schemas.d.ts

@@ -0,0 +1,3 @@
+import { JSONValue } from '@pikku/core';
+import { CLILogger } from '../services/cli-logger.service.js';
+export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, requiredSchemas: Set<string>, supportsImportAttributes: boolean, packageName?: string | null): Promise<void>;

package/dist/src/utils/serialize-schemas.js

@@ -0,0 +1,38 @@
+import { writeFileInDir } from './file-writer.js';
+import { mkdir, writeFile } from 'fs/promises';
+function toValidIdentifier(name) {
+    let result = name.replace(/[-./]/g, '_');
+    if (/^\d/.test(result)) {
+        result = '_' + result;
+    }
+    return result;
+}
+export async function saveSchemas(logger, schemaParentDir, schemas, requiredSchemas, supportsImportAttributes, packageName) {
+    await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
+    if (requiredSchemas.size === 0) {
+        logger.info(`• Skipping schemas since none found.\x1b[0m`);
+        return;
+    }
+    await mkdir(`${schemaParentDir}/schemas`, { recursive: true });
+    await Promise.all(Object.entries(schemas).map(async ([schemaName, schema]) => {
+        if (requiredSchemas.has(schemaName)) {
+            await writeFile(`${schemaParentDir}/schemas/${schemaName}.schema.json`, JSON.stringify(schema), 'utf-8');
+        }
+    }));
+    const availableSchemas = Array.from(requiredSchemas).filter((schema) => schemas[schema]);
+    const packageNameArg = packageName ? `, '${packageName}'` : '';
+    const schemaImports = availableSchemas
+        .map((schema) => {
+        const identifier = toValidIdentifier(schema);
+        return `
+import * as ${identifier} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
+addSchema('${schema}', ${identifier}${packageNameArg})
+`;
+    })
+        .join('\n');
+    const importStatement = availableSchemas.length > 0
+        ? `import { addSchema } from '@pikku/core/schema'`
+        : '// No schemas to register';
+    await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, `${importStatement}
+${schemaImports}`, { logWrite: true });
+}