@pikku/cli 0.11.2 → 0.12.0

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

@@ -0,0 +1,26 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializeWorkflowRegistration = (outputPath, metaImportPath, workflowNames, workflowFiles, _graphFiles, packageMappings, _packageName) => {
+    const lines = [];
+    const hasWorkflows = workflowNames.length > 0;
+    const hasDslWorkflows = workflowFiles.size > 0;
+    if (hasDslWorkflows) {
+        lines.push(`import { addWorkflow } from '@pikku/core/workflow'`);
+    }
+    if (hasWorkflows) {
+        lines.push(`import '${metaImportPath}'`);
+    }
+    const sortedWorkflows = Array.from(workflowFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [, { path, exportedName }] of sortedWorkflows) {
+        const importPath = getFileImportRelativePath(outputPath, path, packageMappings);
+        lines.push(`import { ${exportedName} } from '${importPath}'`);
+    }
+    lines.push('');
+    for (const [pikkuFuncId, { exportedName }] of sortedWorkflows) {
+        lines.push(`addWorkflow('${pikkuFuncId}', ${exportedName})`);
+    }
+    if (hasWorkflows) {
+        lines.push('');
+        lines.push(`export type WorkflowNames = '${workflowNames.join("' | '")}'`);
+    }
+    return lines.join('\n');
+};

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

@@ -1,4 +1 @@
-/**
- * Generates type definitions for workflow wirings
- */
-export declare const serializeWorkflowTypes: (functionTypesImportPath: string, rpcMapImportPath: string) => string;
+export declare const serializeWorkflowTypes: (functionTypesImportPath: string, rpcMapImportPath: string, workflowMapImportPath: string) => string;

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

@@ -1,24 +1,27 @@
-/**
- * Generates type definitions for workflow wirings
- */
-export const serializeWorkflowTypes = (functionTypesImportPath, rpcMapImportPath) => {
-    return `/**
- * Workflow-specific type definitions for tree-shaking optimization
- */
-
-import { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow'
+export const serializeWorkflowTypes = (functionTypesImportPath, rpcMapImportPath, workflowMapImportPath) => {
+    return `import { WorkflowCancelledException } from '@pikku/core/workflow'
+import {
+  workflow as coreWorkflow,
+  workflowStart as coreWorkflowStart,
+  workflowStatus as coreWorkflowStatus,
+  graphStart as coreGraphStart,
+} from '@pikku/core/workflow'
+import { template } from '@pikku/core/workflow'
+import {
+  pikkuWorkflowGraph as corePikkuWorkflowGraph,
+  type PikkuWorkflowGraphConfig,
+  type PikkuWorkflowGraphResult,
+} from '@pikku/core/workflow'
+import type { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow'
+
+export { WorkflowCancelledException }
 import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '${functionTypesImportPath}'
-import type { RPCMap } from '${rpcMapImportPath}'
+import type { RPCMap, FlattenedRPCMap } from '${rpcMapImportPath}'
+import type { WorkflowMap, GraphsMap } from '${workflowMapImportPath}'
+
+export { template }
 
-/**
- * Typed workflow wire with RPC awareness
- * Provides type-safe workflow.do() for RPC steps
- */
 export interface TypedWorkflow extends PikkuWorkflowWire {
-  /**
-   * Execute a workflow step with RPC invocation (typed based on available RPCs)
-   * @template K - RPC name from the RPC map
-   */
   do<K extends keyof RPCMap>(
     stepName: string,
     rpcName: K,
@@ -26,10 +29,6 @@ export interface TypedWorkflow extends PikkuWorkflowWire {
     options?: WorkflowStepOptions
   ): Promise<RPCMap[K]['output']>
 
-  /**
-   * Execute a workflow step with inline function
-   * @template T - Return type of the inline function
-   */
   do<T>(
     stepName: string,
     fn: () => T | Promise<T>,
@@ -37,31 +36,11 @@ export interface TypedWorkflow extends PikkuWorkflowWire {
   ): Promise<T>
 }
 
-/**
- * Workflow function type with typed workflow service
- * Includes the workflow wire object with typed RPC methods
- */
 export type PikkuFunctionWorkflow<
   In = unknown,
   Out = never
-> = PikkuFunctionSessionless<
-  In,
-  Out,
-  'workflow'
->
-
-/**
- * Creates a workflow function with typed input and output.
- * Workflow functions have access to the workflow wire object for step execution.
- *
- * This is the permissive mode - workflows that don't conform to simple DSL will fall back
- * to basic extraction with a warning.
- *
- * @template In - Input type for the workflow
- * @template Out - Output type for the workflow
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- */
+> = PikkuFunctionSessionless<In, Out, 'workflow'>
+
 export const pikkuWorkflowFunc = <In, Out = unknown>(
   func:
     | PikkuFunctionWorkflow<In, Out>
@@ -70,25 +49,7 @@ export const pikkuWorkflowFunc = <In, Out = unknown>(
   return typeof func === 'function' ? { func } : func
 }
 
-/**
- * Creates a simple workflow function with typed input and output.
- * Simple workflows must conform to the restricted DSL for static analysis.
- *
- * This is the strict mode - workflows that don't conform to simple DSL will cause
- * a critical error during inspection.
- *
- * Constraints:
- * - Must use only workflow.do() with RPC form (no inline functions)
- * - Only if/else, for..of, and Promise.all(array.map()) control flow allowed
- * - Step names must be unique (except across mutually exclusive branches)
- * - All workflow calls must be awaited
- *
- * @template In - Input type for the workflow
- * @template Out - Output type for the workflow
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- */
-export const pikkuSimpleWorkflowFunc = <In, Out = unknown>(
+export const pikkuWorkflowComplexFunc = <In, Out = unknown>(
   func:
     | PikkuFunctionWorkflow<In, Out>
     | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
@@ -96,5 +57,102 @@ export const pikkuSimpleWorkflowFunc = <In, Out = unknown>(
   return typeof func === 'function' ? { func } : func
 }
 
+type TypedRef<T> = { $ref: string; path?: string } & { __phantomType?: T }
+
+type TemplateString = {
+  $template: {
+    parts: string[]
+    expressions: Array<{ $ref: string; path?: string }>
+  }
+} & { __brand: 'TemplateString' }
+
+type InputWithRefs<T> = {
+  [K in keyof T]?: T[K] | TypedRef<T[K]> | TypedRef<unknown> | TemplateString
+}
+
+type NodeInputType<FuncMap extends Record<string, string>, K extends keyof FuncMap> =
+  FuncMap[K] extends keyof FlattenedRPCMap
+    ? InputWithRefs<FlattenedRPCMap[FuncMap[K]]['input']>
+    : Record<string, unknown>
+
+type NodeOutputKeys<FuncMap extends Record<string, string>, N extends string> =
+  N extends keyof FuncMap
+    ? FuncMap[N] extends keyof FlattenedRPCMap
+      ? keyof FlattenedRPCMap[FuncMap[N]]['output'] & string
+      : string
+    : string
+
+type RefFunction<FuncMap extends Record<string, string>> = {
+  <N extends Extract<keyof FuncMap, string>>(
+    nodeId: N,
+    path: NodeOutputKeys<FuncMap, N>
+  ): TypedRef<unknown>
+  (nodeId: 'trigger' | '$item', path?: string): TypedRef<unknown>
+}
+
+type TemplateFunction = (templateStr: string, refs: TypedRef<unknown>[]) => TemplateString
+
+type GraphNodeConfigMap<FuncMap extends Record<string, string>> = {
+  [K in Extract<keyof FuncMap, string>]?: {
+    next?: NextConfig<Extract<keyof FuncMap, string>>
+    input?:
+      | NodeInputType<FuncMap, K>
+      | (() => NodeInputType<FuncMap, K>)
+      | ((ref: RefFunction<FuncMap>, template: TemplateFunction) => NodeInputType<FuncMap, K>)
+    onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[]
+  }
+}
+
+type NextConfig<NodeIds extends string> = NodeIds | NodeIds[] | { if: string; then: NodeIds; else?: NodeIds }
+
+export function pikkuWorkflowGraph<
+  const FuncMap extends Record<string, keyof FlattenedRPCMap & string>
+>(
+  config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>
+): PikkuWorkflowGraphResult {
+  return corePikkuWorkflowGraph(config as any)
+}
+
+export const workflow = <Name extends keyof WorkflowMap>(
+  workflowName: Name,
+  options?: { pollIntervalMs?: number }
+) => {
+  return coreWorkflow<WorkflowMap>(workflowName as string & keyof WorkflowMap, options) as PikkuFunctionConfig<
+    WorkflowMap[Name]['input'],
+    WorkflowMap[Name]['output'],
+    'session' | 'rpc'
+  >
+}
+
+export const workflowStart = <Name extends keyof WorkflowMap>(
+  workflowName: Name
+) => {
+  return coreWorkflowStart<WorkflowMap>(workflowName as string & keyof WorkflowMap) as PikkuFunctionConfig<
+    WorkflowMap[Name]['input'],
+    { runId: string },
+    'session' | 'rpc'
+  >
+}
+
+export const workflowStatus = <Name extends keyof WorkflowMap>(
+  _workflowName: Name
+) => {
+  return coreWorkflowStatus<WorkflowMap>(_workflowName as string & keyof WorkflowMap) as PikkuFunctionConfig<
+    { runId: string },
+    { id: string; status: 'running' | 'completed' | 'failed' | 'cancelled'; output?: WorkflowMap[Name]['output']; error?: { message?: string } },
+    'session' | 'rpc'
+  >
+}
+
+export const graphStart = <Name extends keyof GraphsMap, Node extends string & keyof GraphsMap[Name]>(
+  graphName: Name,
+  startNode: Node
+) => {
+  return coreGraphStart<GraphsMap>(graphName as string & keyof GraphsMap, startNode as string) as PikkuFunctionConfig<
+    GraphsMap[Name][Node] extends { input: infer I } ? I : never,
+    { runId: string },
+    'session' | 'rpc'
+  >
+}
 `;
 };

package/dist/src/functions/wirings/workflow/serialize-workflow-workers.d.ts

@@ -1,4 +1,4 @@
 /**
- * Generate queue workers and RPC functions for workflow steps and orchestrator
+ * Generate queue workers for workflow orchestration
  */
 export declare const serializeWorkflowWorkers: (pathToPikkuTypes: string) => string;

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

@@ -1,16 +1,12 @@
 /**
- * Generate queue workers and RPC functions for workflow steps and orchestrator
+ * Generate queue workers for workflow orchestration
  */
 export const serializeWorkflowWorkers = (pathToPikkuTypes) => {
     return `/**
- * Auto-generated workflow queue workers and RPC functions
- * Do not edit manually - regenerate with 'npx pikku'
+ * Workflow queue workers for orchestration
  */
 import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
 
-/**
- * Worker input types for generated queue workers
- */
 export type WorkflowStepInput = {
   runId: string
   stepName: string
@@ -18,43 +14,34 @@ export type WorkflowStepInput = {
   data: any
 }
 
-export const pikkuWorkflowWorker = pikkuSessionlessFunc<
-  WorkflowStepInput,
-  void
->({
+export const pikkuWorkflowWorker = pikkuSessionlessFunc<WorkflowStepInput, void>({
   func: async ({ workflowService }, { runId, stepName, rpcName, data }, { rpc }) => {
     await workflowService!.executeWorkflowStep(runId, stepName, rpcName, data, rpc)
   }
 })
 
-export const pikkuWorkflowOrchestrator = pikkuSessionlessFunc<
-  { runId: string },
-  void
->({
+export const pikkuWorkflowOrchestrator = pikkuSessionlessFunc<{ runId: string }, void>({
   func: async ({ workflowService }, { runId }, { rpc }) => {
     await workflowService!.orchestrateWorkflow(runId, rpc)
   }
 })
 
-export const pikkuWorkflowSleeper = pikkuSessionlessFunc<
-  { runId: string, stepId: string },
-  void
->({
+export const pikkuWorkflowSleeper = pikkuSessionlessFunc<{ runId: string, stepId: string }, void>({
   func: async ({ workflowService }, { runId, stepId }) => {
-    await workflowService!.executeWorkflowSleep(runId, stepId)
+    await workflowService!.executeWorkflowSleepCompleted(runId, stepId)
   },
-  name: 'pikkuWorkflowStepSleeper',
-  internal: true,
+  remote: true,
 })
 
-wireQueueWorker({
-  queueName: 'pikku-workflow-step-worker',
-  func: pikkuWorkflowWorker,
+export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<{ rpcName: string, data?: any }, any>({
+  func: async (_services, { rpcName, data }, { rpc }) => {
+    return await (rpc.invoke as any)(rpcName, data)
+  },
+  remote: true,
 })
 
-wireQueueWorker({
-  queueName: 'pikku-workflow-orchestrator',
-  func: pikkuWorkflowOrchestrator,
-})
+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, 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,
     };
@@ -183,17 +200,47 @@ export const createSingletonServices = async (config) => {
             // Run inspector WITHOUT filters to get full state
             const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`, {
                 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}`);
@@ -211,11 +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,10 +3,13 @@ export interface CommandSummaryStats {
     channels?: number;
     functions?: number;
     scheduledTasks?: number;
+    triggers?: number;
     queueWorkers?: number;
     mcpEndpoints?: number;
     cliCommands?: number;
     workflows?: number;
+    nodes?: number;
+    workflowGraphs?: number;
     [key: string]: number | undefined;
 }
 /**

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

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

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/generate-bootstrap-file.js

@@ -7,7 +7,7 @@ export const generateBootstrapFile = async (logger, config, bootstrapFile, speci
     if (hasMiddleware) {
         commonImports.push(config.middlewareFile);
     }
-    commonImports.push(config.functionsMetaMinFile, config.functionsFile);
+    commonImports.push(config.functionsMetaFile, config.functionsFile);
     // Add schema if it exists
     if (schemas) {
         commonImports.push(`${config.schemaDirectory}/register.gen.ts`);