@pikku/cli 0.11.3 → 0.12.0

package/dist/src/functions/wirings/console/serialize-console-functions.js

@@ -0,0 +1,229 @@
+export const serializeConsoleFunctions = (pathToPikkuTypes) => {
+    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes, external } from '${pathToPikkuTypes}'
+import { streamAIAgent, resumeAIAgent } from '@pikku/core/ai-agent'
+import type { AIStreamChannel } from '@pikku/core/ai-agent'
+
+export const streamAgentRun = pikkuSessionlessFunc<
+  { agentName: string; message: string; threadId: string; resourceId?: string },
+  any
+>({
+  title: 'Stream Agent Run',
+  description: 'SSE stream of agent conversation responses.',
+  expose: false,
+  auth: false,
+  func: async (services, data, { channel }) => {
+    if (!channel) return
+    await streamAIAgent(
+      data.agentName,
+      {
+        message: data.message,
+        threadId: data.threadId,
+        resourceId: data.resourceId || 'console-playground',
+      },
+      channel as unknown as AIStreamChannel,
+      { singletonServices: services }
+    )
+  },
+})
+
+export const resumeAgentRun = pikkuSessionlessFunc<
+  {
+    agentName: string
+    toolCallId: string
+    approved: boolean
+  },
+  any
+>({
+  title: 'Resume Agent Run',
+  description: 'Resume an agent run after tool approval/denial.',
+  expose: false,
+  auth: false,
+  func: async (services, data, { channel }) => {
+    if (!channel) return
+    await resumeAIAgent(
+      {
+        toolCallId: data.toolCallId,
+        approved: data.approved,
+      },
+      channel as unknown as AIStreamChannel,
+      { singletonServices: services }
+    )
+  },
+})
+
+export interface SetSecretInput {
+  secretId: string
+  value: unknown
+}
+
+export interface SetSecretOutput {
+  success: boolean
+}
+
+export const setSecret = pikkuSessionlessFunc<SetSecretInput, SetSecretOutput>({
+  description: 'Set the value of a secret',
+  expose: true,
+  auth: false,
+  func: async ({ secrets }, { secretId, value }) => {
+    await secrets.setSecretJSON(secretId, value)
+    return { success: true }
+  },
+})
+
+export interface GetVariableInput {
+  variableId: string
+}
+
+export interface GetVariableOutput {
+  exists: boolean
+  value: unknown | null
+}
+
+export const getVariable = pikkuSessionlessFunc<
+  GetVariableInput,
+  GetVariableOutput
+>({
+  description: 'Get the current value of a variable',
+  expose: true,
+  auth: false,
+  func: async ({ variables }, { variableId }) => {
+    const exists = await variables.has(variableId)
+    if (!exists) {
+      return { exists: false, value: null }
+    }
+    try {
+      const value = await variables.getJSON(variableId)
+      return { exists: true, value }
+    } catch {
+      const value = await variables.get(variableId)
+      return { exists: true, value }
+    }
+  },
+})
+
+export interface SetVariableInput {
+  variableId: string
+  value: unknown
+}
+
+export interface SetVariableOutput {
+  success: boolean
+}
+
+export const setVariable = pikkuSessionlessFunc<
+  SetVariableInput,
+  SetVariableOutput
+>({
+  description: 'Set the value of a variable',
+  expose: true,
+  auth: false,
+  func: async ({ variables }, { variableId, value }) => {
+    if (typeof value === 'string') {
+      await variables.set(variableId, value)
+    } else {
+      await variables.setJSON(variableId, value)
+    }
+    return { success: true }
+  },
+})
+
+export interface GetSecretInput {
+  secretId: string
+}
+
+export interface GetSecretOutput {
+  exists: boolean
+  value: unknown | null
+}
+
+export const getSecret = pikkuSessionlessFunc<
+  GetSecretInput,
+  GetSecretOutput
+>({
+  description: 'Get the current value of a secret',
+  expose: true,
+  auth: false,
+  func: async ({ secrets }, { secretId }) => {
+    const exists = await secrets.hasSecret(secretId)
+    if (!exists) {
+      return { exists: false, value: null }
+    }
+    const value = await secrets.getSecretJSON(secretId)
+    return { exists: true, value }
+  },
+})
+
+export interface StartWorkflowRunInput {
+  workflowName: string
+  input?: any
+}
+
+export interface StartWorkflowRunOutput {
+  runId: string
+}
+
+export const startWorkflowRun = pikkuSessionlessFunc<
+  StartWorkflowRunInput,
+  StartWorkflowRunOutput
+>({
+  title: 'Start Workflow Run',
+  description: 'Starts a new workflow run by name with optional input.',
+  expose: true,
+  auth: false,
+  func: async (_services, { workflowName, input }, { rpc }) => {
+    return await (rpc as any).startWorkflow(workflowName, input || {})
+  },
+})
+
+export const consoleRoutes = defineHTTPRoutes({
+  auth: false,
+  routes: {
+    externalIconOptions: {
+      route: '/external/icon/:alias',
+      method: 'options',
+      func: pikkuSessionlessFunc<{ alias: string }>(async () => void 0),
+    },
+    externalIcon: {
+      route: '/external/icon/:alias',
+      method: 'get',
+      func: external('console:getExternalIcon'),
+    },
+    agentStreamOptions: {
+      route: '/api/agents/:agentName/stream',
+      method: 'options',
+      func: pikkuSessionlessFunc<{ agentName: string }>(async () => void 0),
+    },
+    agentStream: {
+      route: '/api/agents/:agentName/stream',
+      method: 'post',
+      sse: true,
+      func: streamAgentRun,
+    },
+    agentResumeOptions: {
+      route: '/api/agents/:agentName/resume',
+      method: 'options',
+      func: pikkuSessionlessFunc<{ agentName: string }>(async () => void 0),
+    },
+    agentResume: {
+      route: '/api/agents/:agentName/resume',
+      method: 'post',
+      sse: true,
+      func: resumeAgentRun,
+    },
+    workflowRunStreamOptions: {
+      route: '/api/workflow-run/:runId/stream',
+      method: 'options',
+      func: pikkuSessionlessFunc<{ runId: string }>(async () => void 0),
+    },
+    workflowRunStream: {
+      route: '/api/workflow-run/:runId/stream',
+      method: 'get',
+      sse: true,
+      func: external('console:streamWorkflowRun'),
+    },
+  },
+})
+
+wireHTTPRoutes({ routes: { console: consoleRoutes } })
+`;
+};

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

@@ -0,0 +1 @@
+export declare const serializeNodeTypes: (rpcMapImportPath: string, categories: string[] | undefined) => string;

package/dist/src/functions/wirings/console/serialize-node-types.js

@@ -0,0 +1,11 @@
+export const serializeNodeTypes = (rpcMapImportPath, categories) => {
+    const categoryType = categories?.length
+        ? categories.map((c) => `'${c}'`).join(' | ')
+        : 'never';
+    return `import type { FlattenedRPCMap } from '${rpcMapImportPath}'
+
+export type NodeCategory = ${categoryType}
+
+export type NodeRPCName = keyof FlattenedRPCMap
+`;
+};

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

@@ -0,0 +1 @@
+export declare const pikkuExternalTypes: 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/functions/pikku-command-external-types.js

@@ -0,0 +1,33 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeExternalTypes } from './serialize-external-types.js';
+export const pikkuExternalTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        if (!config.externalPackage) {
+            return;
+        }
+        const visitState = await getInspectorState();
+        const { externalTypesFile, packageMappings, servicesFile, secretsFile, variablesFile, } = config;
+        checkRequiredTypes(visitState.filesAndMethodsErrors, {
+            singletonServicesType: true,
+        });
+        const { singletonServicesType, pikkuConfigType } = visitState.filesAndMethods;
+        if (!singletonServicesType) {
+            throw new Error('Required types not found');
+        }
+        const configTypeImport = pikkuConfigType
+            ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(externalTypesFile, pikkuConfigType.typePath, packageMappings)}'`
+            : '// Config type not found, will use fallback';
+        const content = serializeExternalTypes(`import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(externalTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, configTypeImport, `import type { RequiredSingletonServices } from '${getFileImportRelativePath(externalTypesFile, servicesFile, packageMappings)}'`, `import { TypedSecretService } from '${getFileImportRelativePath(externalTypesFile, secretsFile, packageMappings)}'`, `import { TypedVariablesService } from '${getFileImportRelativePath(externalTypesFile, variablesFile, packageMappings)}'`);
+        await writeFileInDir(logger, externalTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating external types',
+            commandEnd: 'Created external types',
+        }),
+    ],
+});

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

@@ -1 +1 @@
-export declare const pikkuFunctionTypesSplit: any;
+export declare const pikkuFunctionTypesSplit: 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/functions/pikku-command-function-types-split.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
@@ -21,7 +21,7 @@ export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
         const configTypeImport = pikkuConfigType
             ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
             : '// Config type not found, will use fallback';
-        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport, config.externalPackageName);
+        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport, config.externalPackageName, undefined, config.node?.categories);
         await writeFileInDir(logger, functionTypesFile, content);
     },
     middleware: [

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

@@ -1 +1 @@
-export declare const pikkuFunctionTypes: any;
+export declare const pikkuFunctionTypes: 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/functions/pikku-command-function-types.js

@@ -1,17 +1,17 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
 export const pikkuFunctionTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, forgeTypesFile, } = config;
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, triggersTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, nodeTypesFile, secretTypesFile, externalTypesFile, } = config;
         const getImportPath = (file) => config.externalPackage
             ? null
             : getFileImportRelativePath(typesFile, file, packageMappings);
-        // Forge types are included for external packages (they need wireForgeNode/wireForgeCredential)
-        const getForgeImportPath = (file) => getFileImportRelativePath(typesFile, file, packageMappings);
-        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getImportPath(httpTypesFile), getImportPath(channelsTypesFile), getImportPath(schedulersTypesFile), getImportPath(queueTypesFile), getImportPath(mcpTypesFile), getImportPath(cliTypesFile), getForgeImportPath(forgeTypesFile));
+        // Node and trigger types are included for external packages
+        const getAlwaysImportPath = (file) => getFileImportRelativePath(typesFile, file, packageMappings);
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getImportPath(httpTypesFile), getImportPath(channelsTypesFile), getAlwaysImportPath(triggersTypesFile), getImportPath(schedulersTypesFile), getImportPath(queueTypesFile), getImportPath(mcpTypesFile), getImportPath(cliTypesFile), getAlwaysImportPath(nodeTypesFile), getAlwaysImportPath(secretTypesFile), config.externalPackage ? getAlwaysImportPath(externalTypesFile) : null);
         await writeFileInDir(logger, typesFile, content);
     },
     middleware: [

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

@@ -1 +1 @@
-export declare const pikkuFunctions: any;
+export declare const pikkuFunctions: 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/functions/pikku-command-functions.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 { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeFunctionImports } from './serialize-function-imports.js';

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

@@ -1,2 +1,2 @@
 export declare const serializeServicesMap: (allSingletonServices: string[], allWireServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, wireServicesImport: string) => string;
-export declare const pikkuServices: any;
+export declare const pikkuServices: 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/functions/pikku-command-services.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';

package/dist/src/functions/wirings/functions/schemas.d.ts

@@ -1,4 +1 @@
-/**
- * Generate JSON schemas from TypeScript types and Zod schemas
- */
-export declare const pikkuSchemas: any;
+export declare const pikkuSchemas: 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/functions/schemas.js

@@ -1,21 +1,19 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { saveSchemas, generateSchemas, generateZodSchemas, } from '../../../utils/schema-generator.js';
+import { pikkuSessionlessFunc } from '#pikku';
+import { saveSchemas } from '../../../utils/serialize-schemas.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-/**
- * Generate JSON schemas from TypeScript types and Zod schemas
- */
 export const pikkuSchemas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes, config.schema?.additionalProperties, visitState.zodLookup);
-        const zodSchemas = await generateZodSchemas(logger, visitState.zodLookup, visitState.functions.typesMap);
-        await saveSchemas(logger, config.schemaDirectory, { ...schemas, ...zodSchemas }, visitState.functions.typesMap, visitState.functions.meta, config.schema?.supportsImportAttributes || true, config.schemasFromTypes, visitState.zodLookup, config.externalPackageName || null);
+        if (Object.keys(visitState.schemas).length === 0) {
+            return undefined;
+        }
+        await saveSchemas(logger, config.schemaDirectory, visitState.schemas, visitState.requiredSchemas, config.schema?.supportsImportAttributes ?? true, config.externalPackageName || null);
         return true;
     },
     middleware: [
         logCommandInfoAndTime({
-            commandStart: 'Generating schemas',
-            commandEnd: 'Generated schemas',
+            commandStart: 'Writing schemas',
+            commandEnd: 'Wrote schemas',
         }),
     ],
 });

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

@@ -0,0 +1 @@
+export declare const serializeExternalTypes: (singletonServicesTypeImport: string, singletonServicesTypeName: string, configTypeImport: string, requiredServicesTypeImport: string, typedSecretServiceImport: string, typedVariablesServiceImport: string) => string;

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

@@ -0,0 +1,77 @@
+export const serializeExternalTypes = (singletonServicesTypeImport, singletonServicesTypeName, configTypeImport, requiredServicesTypeImport, typedSecretServiceImport, typedVariablesServiceImport) => {
+    return `/**
+ * External package types for pikkuExternalConfig and pikkuExternalServices
+ */
+
+${singletonServicesTypeImport}
+${configTypeImport}
+${requiredServicesTypeImport}
+${typedSecretServiceImport}
+${typedVariablesServiceImport}
+
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
+
+/**
+ * Base services provided to external package service factories.
+ * These are always available from the parent application.
+ */
+export type ExternalBaseServices = {
+  logger: SingletonServices['logger']
+  variables: TypedVariablesService
+  secrets: TypedSecretService
+}
+
+/**
+ * Creates a Pikku config factory for external packages.
+ * Unlike pikkuConfig, this receives ExternalBaseServices (logger, variables, secrets)
+ * from the parent application, so external packages can read variables/secrets during config creation.
+ */
+export const pikkuExternalConfig = <ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & ExternalBaseServices>(
+  func: (services: ExistingServices) => Promise<Config>
+) => {
+  return async (_variables: any, existingServices?: Partial<SingletonServices>): Promise<Config> => {
+    const { secrets, variables, ...rest } = (existingServices ?? {}) as unknown as SingletonServices
+    return func({ ...rest, secrets: new TypedSecretService(secrets), variables: new TypedVariablesService(variables) } as ExistingServices)
+  }
+}
+
+/**
+ * Creates a Pikku singleton services factory for external packages.
+ * Unlike pikkuServices, this expects the parent application to provide
+ * logger, variables, and secrets - no fallbacks needed.
+ *
+ * @param func - External services factory function that receives config and base services
+ * @returns The singleton services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSingletonServices = pikkuExternalServices(async (
+ *   config,
+ *   { secrets }
+ * ) => {
+ *   const creds = await secrets.getSecretJSON<GithubCredentials>('GITHUB_CREDENTIALS')
+ *   const github = new GithubService(creds)
+ *   return { github }
+ * })
+ * \`\`\`
+ */
+export const pikkuExternalServices = <T extends Record<string, any>, ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & ExternalBaseServices>(
+  func: (config: Config, services: ExistingServices) => Promise<T>
+) => {
+  return async (config: Config, existingServices?: Partial<SingletonServices>): Promise<RequiredSingletonServices> => {
+    const { logger, variables, secrets } = (existingServices ?? {}) as unknown as SingletonServices
+    const typedVariables = new TypedVariablesService(variables)
+    const typedSecrets = new TypedSecretService(secrets)
+    const result = await func(config, { ...existingServices, logger, variables: typedVariables, secrets: typedSecrets } as ExistingServices)
+    return {
+      config,
+      logger,
+      variables: typedVariables,
+      secrets: typedSecrets,
+      ...result,
+    } as unknown as RequiredSingletonServices
+  }
+}
+`;
+};

package/dist/src/functions/wirings/functions/serialize-function-imports.d.ts

@@ -1,8 +1,7 @@
-import { FunctionsMeta, FunctionsRuntimeMeta } from '@pikku/core';
+import { FunctionsMeta } from '@pikku/core';
 export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
     path: string;
     exportedName: string;
 }>, functionsMeta: FunctionsMeta, packageMappings?: Record<string, string>, 
 /** Package name for external packages (e.g., '@pikku/templates-function-external') */
 externalPackageName?: string) => string;
-export declare const generateRuntimeMeta: (functions: FunctionsMeta) => FunctionsRuntimeMeta;

package/dist/src/functions/wirings/functions/serialize-function-imports.js

@@ -11,18 +11,23 @@ externalPackageName) => {
     const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
     // Third argument to addFunction is the package name (null for main package)
     const packageArg = externalPackageName ? `, '${externalPackageName}'` : '';
+    const usedAliases = new Set();
     for (const [name, { path, exportedName }] of sortedEntries) {
         const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        // pikkuFunc/pikkuSessionlessFunc/pikkuVoidFunc always return config objects
-        // For directly exported functions, we can just import and register them
         if (name === exportedName) {
+            usedAliases.add(exportedName);
             serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
             serializedRegistrations.push(`addFunction('${name}', ${exportedName}${packageArg})`);
         }
-        // For renamed functions, we need to import and alias them
         else {
-            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${name}${packageArg})`);
+            let safeAlias = name.replace(/[^a-zA-Z0-9_$]/g, '_');
+            let suffix = 2;
+            while (usedAliases.has(safeAlias)) {
+                safeAlias = `${name.replace(/[^a-zA-Z0-9_$]/g, '_')}_${suffix++}`;
+            }
+            usedAliases.add(safeAlias);
+            serializedImports.push(`import { ${exportedName} as ${safeAlias} } from '${filePath}'`);
+            serializedRegistrations.push(`addFunction('${name}', ${safeAlias}${packageArg})`);
         }
     }
     // Add a blank line between imports and registrations
@@ -32,15 +37,3 @@ externalPackageName) => {
     // Combine the imports and registrations
     return [...serializedImports, ...serializedRegistrations].join('\n');
 };
-export const generateRuntimeMeta = (functions) => {
-    const runtimeMeta = {};
-    for (const [key, { pikkuFuncName, inputSchemaName, outputSchemaName, expose },] of Object.entries(functions)) {
-        runtimeMeta[key] = {
-            pikkuFuncName,
-            inputSchemaName,
-            outputSchemaName,
-            expose,
-        };
-    }
-    return runtimeMeta;
-};

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

@@ -1,4 +1,4 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, wireServicesTypeImport: string, wireServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string, packageName?: string) => string;
+export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, wireServicesTypeImport: string, wireServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string, packageName?: string, workflowTypesImport?: string, nodeCategories?: string[]) => string;