@pikku/cli 0.11.2 → 0.12.0

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

@@ -38,6 +38,10 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
                     ...extendedConfig.packageMappings,
                     ...config.packageMappings,
                 },
+                externalPackages: {
+                    ...extendedConfig.externalPackages,
+                    ...config.externalPackages,
+                },
                 ignoreFiles: config.ignoreFiles ??
                     extendedConfig.ignoreFiles ?? [
                     '**/*.test.ts',
@@ -58,6 +62,7 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
                 ...config,
                 configDir,
                 packageMappings: config.packageMappings || {},
+                externalPackages: config.externalPackages || {},
                 rootDir: config.rootDir
                     ? resolve(configDir, config.rootDir)
                     : configDir,
@@ -99,12 +104,6 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.functionsMetaJsonFile) {
             result.functionsMetaJsonFile = join(functionDir, 'pikku-functions-meta.gen.json');
         }
-        if (!result.functionsMetaMinFile) {
-            result.functionsMetaMinFile = join(functionDir, 'pikku-functions-meta.min.gen.ts');
-        }
-        if (!result.functionsMetaMinJsonFile) {
-            result.functionsMetaMinJsonFile = join(functionDir, 'pikku-functions-meta.min.gen.json');
-        }
         if (!result.functionTypesFile) {
             result.functionTypesFile = join(functionDir, 'pikku-function-types.gen.ts');
         }
@@ -163,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');
@@ -199,9 +217,6 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.workflowsWiringMetaFile) {
             result.workflowsWiringMetaFile = join(workflowDir, 'pikku-workflow-wirings-meta.gen.ts');
         }
-        if (!result.workflowsWiringMetaJsonFile) {
-            result.workflowsWiringMetaJsonFile = join(workflowDir, 'pikku-workflow-wirings-meta.gen.json');
-        }
         if (!result.workflowsWorkersFile) {
             result.workflowsWorkersFile = join(workflowDir, 'pikku-workflow-workers.gen.ts');
         }
@@ -211,6 +226,10 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.workflowTypesFile) {
             result.workflowTypesFile = join(workflowDir, 'pikku-workflow-types.gen.ts');
         }
+        // Workflow meta directory (individual JSON files for each workflow)
+        if (!result.workflowMetaDir) {
+            result.workflowMetaDir = join(workflowDir, 'meta');
+        }
         // Services
         if (!result.servicesFile) {
             result.servicesFile = join(result.outDir, 'pikku-services.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,6 +246,9 @@ 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');
@@ -250,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');
@@ -266,11 +302,50 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.cliTypesFile) {
             result.cliTypesFile = join(cliDir, 'pikku-cli-types.gen.ts');
         }
+        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.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;
@@ -285,6 +360,22 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!isAbsolute(result.tsconfig)) {
             result.tsconfig = join(result.rootDir, result.tsconfig);
         }
+        if (result.externalPackage) {
+            const packageJsonPath = join(result.rootDir, 'package.json');
+            try {
+                const packageJsonContent = await readFile(packageJsonPath, 'utf-8');
+                const packageJson = JSON.parse(packageJsonContent);
+                if (!packageJson.name ||
+                    typeof packageJson.name !== 'string' ||
+                    packageJson.name.trim() === '') {
+                    throw new Error(`package.json at ${packageJsonPath} is missing a valid "name" field`);
+                }
+                result.externalPackageName = packageJson.name;
+            }
+            catch (e) {
+                throw new Error(`externalPackage is true but could not read or parse package.json at ${packageJsonPath}: ${e.message}`);
+            }
+        }
         return result;
     }
     catch (e) {

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 });
+}

package/dist/src/utils/strip-verbose-meta.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Utility functions to strip verbose/visualization-only fields from meta objects
+ * for creating minimal runtime-only versions.
+ *
+ * Verbose fields are those used for UI/visualization but not needed at runtime:
+ * - tags, description, summary, errors
+ * - title, displayName
+ * - wires, isDirectFunction, services
+ * - stepName (in workflow nodes)
+ *
+ * Note: middleware and permissions are NOT verbose - they're needed at runtime
+ * for resolving tag middleware and permissions in function-runner.ts
+ *
+ * IMPORTANT: We only strip verbose fields at the direct meta entry level.
+ * For most meta types (HTTP, Queue, Scheduler, etc.), entries have pikkuFuncId.
+ * For workflow graphs, we strip at the root level AND from nodes.
+ * We do NOT strip from deeply nested structures like CLI options where 'description' is required.
+ */
+/**
+ * Strip verbose fields from a meta object.
+ *
+ * Handles different meta structure patterns:
+ * 1. Single workflow graph: { name, pikkuFuncId, nodes: {...}, description, tags }
+ *    -> Strips description, tags at root; strips stepName from each node
+ * 2. Record of meta entries: { "entryName": { pikkuFuncId, description, tags, ... } }
+ *    -> Strips description, tags from each entry (one level deep only)
+ * 3. CLI meta and others with complex nesting: preserved as-is except for pikkuFuncId entries
+ */
+export declare function stripVerboseFields<T>(obj: T): T;
+/**
+ * Check if an object has any verbose fields that would be stripped
+ */
+export declare function hasVerboseFields(obj: unknown): boolean;
+/**
+ * Write both minimal and verbose meta files
+ * Only writes verbose file if it differs from minimal
+ *
+ * @returns Object with paths that were written
+ */
+export declare function writeMetaFiles(writeFile: (path: string, content: string) => Promise<void>, basePath: string, meta: unknown): Promise<{
+    minimal: string;
+    verbose?: string;
+}>;