@pikku/cli 0.11.1 → 0.11.3

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

@@ -2,7 +2,15 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeSchedulerMeta } from './serialize-scheduler-meta.js'
+import {
+  serializeSchedulerMeta,
+  serializeSchedulerMetaTS,
+} from './serialize-scheduler-meta.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import {
+  stripVerboseFields,
+  hasVerboseFields,
+} from '../../../utils/strip-verbose-meta.js'
 
 export const pikkuScheduler: any = pikkuSessionlessFunc<
   void,
@@ -10,15 +18,54 @@ export const pikkuScheduler: any = pikkuSessionlessFunc<
 >({
   func: async ({ logger, config, getInspectorState }) => {
     const visitState = await getInspectorState()
-    const { schedulersWiringFile, schedulersWiringMetaFile, packageMappings } =
-      config
+    const {
+      schedulersWiringFile,
+      schedulersWiringMetaFile,
+      schedulersWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
     const { scheduledTasks } = visitState
 
+    const fullMeta = serializeSchedulerMeta(scheduledTasks.meta)
+
+    // Write minimal JSON (runtime-only fields)
+    const minimalMeta = stripVerboseFields(fullMeta)
     await writeFileInDir(
       logger,
+      schedulersWiringMetaJsonFile,
+      JSON.stringify(minimalMeta, null, 2)
+    )
+
+    // Write verbose JSON only if it has additional fields
+    if (hasVerboseFields(fullMeta)) {
+      const verbosePath = schedulersWiringMetaJsonFile.replace(
+        /\.gen\.json$/,
+        '-verbose.gen.json'
+      )
+      await writeFileInDir(
+        logger,
+        verbosePath,
+        JSON.stringify(fullMeta, null, 2)
+      )
+    }
+
+    const jsonImportPath = getFileImportRelativePath(
       schedulersWiringMetaFile,
-      serializeSchedulerMeta(scheduledTasks.meta)
+      schedulersWiringMetaJsonFile,
+      packageMappings
     )
+
+    await writeFileInDir(
+      logger,
+      schedulersWiringMetaFile,
+      serializeSchedulerMetaTS(
+        scheduledTasks.meta,
+        jsonImportPath,
+        schema?.supportsImportAttributes ?? false
+      )
+    )
+
     await writeFileInDir(
       logger,
       schedulersWiringFile,

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

@@ -3,11 +3,30 @@ import { ScheduledTasksMeta } from '@pikku/core/scheduler'
 export const serializeSchedulerMeta = (
   scheduledTasksMeta: ScheduledTasksMeta
 ) => {
+  return scheduledTasksMeta
+}
+
+export const serializeSchedulerMetaTS = (
+  scheduledTasksMeta: ScheduledTasksMeta,
+  jsonImportPath: string,
+  supportsImportAttributes
+) => {
+  const importStatement = supportsImportAttributes
+    ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+    : `import metaData from '${jsonImportPath}'`
+
   const serializedOutput: string[] = []
   serializedOutput.push("import { pikkuState } from '@pikku/core'")
   serializedOutput.push(
-    `pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`
+    "import { ScheduledTasksMeta } from '@pikku/core/scheduler'"
   )
+  serializedOutput.push(importStatement)
+  serializedOutput.push('')
+  serializedOutput.push(
+    "pikkuState(null, 'scheduler', 'meta', metaData as ScheduledTasksMeta)"
+  )
+  serializedOutput.push('')
+
   const scheduledTasksMetaValues = Object.values(scheduledTasksMeta)
   if (scheduledTasksMetaValues.length > 0) {
     serializedOutput.push(

package/src/functions/wirings/scheduler/serialize-scheduler-types.ts

@@ -13,7 +13,7 @@ import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImport
  * Type definition for scheduled tasks that run at specified intervals.
  * These are sessionless functions that execute based on cron expressions.
  */
-type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void>, PikkuMiddleware>
+type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'session' | 'rpc'>, PikkuMiddleware>
 
 /**
  * Registers a scheduled task with the Pikku framework.

package/src/functions/wirings/services/pikku-command-service-metadata.ts

@@ -0,0 +1,25 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { writeAllServiceMetadata } from '@pikku/inspector'
+
+export const pikkuServiceMetadata: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const state = await getInspectorState()
+
+    // Only write service metadata if there are services to document
+    if (state.serviceMetadata && state.serviceMetadata.length > 0) {
+      writeAllServiceMetadata(state.serviceMetadata, config.outDir)
+      logger.debug(
+        `• Wrote ${state.serviceMetadata.length} service metadata files`
+      )
+    } else {
+      logger.debug('• No service metadata to write')
+    }
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating service metadata',
+      commandEnd: 'Generated service metadata',
+    }),
+  ],
+})

package/src/functions/wirings/workflow/pikku-command-workflow.ts

@@ -1,13 +1,18 @@
 import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { ErrorCode } from '@pikku/inspector'
-import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
+import { convertDslToGraph, ErrorCode } from '@pikku/inspector'
+import type { WorkflowsMeta } from '@pikku/core/workflow'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeWorkflowMeta } from './serialize-workflow-meta.js'
 import { serializeWorkflowTypes } from './serialize-workflow-types.js'
+import { serializeWorkflowRegistration } from './serialize-workflow-registration.js'
 import { serializeWorkflowMap } from './serialize-workflow-map.js'
+import { serializeWorkflowMeta } from './serialize-workflow-meta.js'
 import { serializeWorkflowWorkers } from './serialize-workflow-workers.js'
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import {
+  stripVerboseFields,
+  hasVerboseFields,
+} from '../../../utils/strip-verbose-meta.js'
 import { join } from 'path'
 
 export const pikkuWorkflow: any = pikkuSessionlessFunc<
@@ -19,17 +24,27 @@ export const pikkuWorkflow: any = pikkuSessionlessFunc<
     const {
       workflowsWiringFile,
       workflowsWiringMetaFile,
+      workflowMetaDir,
       workflowMapDeclarationFile,
       workflowTypesFile,
       functionTypesFile,
       typesDeclarationFile,
       packageMappings,
+      schema,
     } = config
     const { workflows, functions: functionState } = visitState
     const { typesMap } = functionState
 
-    // Validate that workflowService service is configured if workflows are defined
-    const hasWorkflows = Object.keys(workflows.meta).length > 0
+    // Get all workflow names (both DSL and graph-based)
+    const dslWorkflowNames = Object.keys(workflows.meta)
+    const graphWorkflowNames = Object.keys(workflows.graphMeta)
+    const allWorkflowNames = [
+      ...new Set([...dslWorkflowNames, ...graphWorkflowNames]),
+    ]
+
+    const hasWorkflows = allWorkflowNames.length > 0
+
+    // Validate that workflowService is configured if workflows are defined
     if (hasWorkflows) {
       const hasWorkflowState =
         visitState.serviceAggregation.allSingletonServices.includes(
@@ -46,38 +61,117 @@ export const pikkuWorkflow: any = pikkuSessionlessFunc<
       }
     }
 
-    // Write workflow metadata
-    await writeFileInDir(
-      logger,
+    // Generate individual JSON files for each workflow (convert DSL to graph format)
+    if (hasWorkflows && workflowMetaDir) {
+      // Write individual JSON files for DSL workflows
+      const dslMeta = workflows.meta as WorkflowsMeta
+      for (const [name, meta] of Object.entries(dslMeta)) {
+        const graphMeta = convertDslToGraph(name, meta)
+
+        // Write minimal version (runtime-only fields)
+        const minimalMeta = stripVerboseFields(graphMeta)
+        const minimalPath = join(workflowMetaDir, `${name}.gen.json`)
+        await writeFileInDir(
+          logger,
+          minimalPath,
+          JSON.stringify(minimalMeta, null, 2),
+          { ignoreModifyComment: true }
+        )
+
+        // Write verbose version only if it has additional fields
+        if (hasVerboseFields(graphMeta)) {
+          const verbosePath = join(workflowMetaDir, `${name}-verbose.gen.json`)
+          await writeFileInDir(
+            logger,
+            verbosePath,
+            JSON.stringify(graphMeta, null, 2),
+            { ignoreModifyComment: true }
+          )
+        }
+      }
+
+      // Write individual JSON files for graph workflows
+      for (const [name, graphMeta] of Object.entries(workflows.graphMeta)) {
+        // Write minimal version (runtime-only fields)
+        const minimalMeta = stripVerboseFields(graphMeta)
+        const minimalPath = join(workflowMetaDir, `${name}.gen.json`)
+        await writeFileInDir(
+          logger,
+          minimalPath,
+          JSON.stringify(minimalMeta, null, 2),
+          { ignoreModifyComment: true }
+        )
+
+        // Write verbose version only if it has additional fields
+        if (hasVerboseFields(graphMeta)) {
+          const verbosePath = join(workflowMetaDir, `${name}-verbose.gen.json`)
+          await writeFileInDir(
+            logger,
+            verbosePath,
+            JSON.stringify(graphMeta, null, 2),
+            { ignoreModifyComment: true }
+          )
+        }
+      }
+    }
+
+    // Generate workflow meta aggregation file
+    if (workflowsWiringMetaFile && workflowMetaDir) {
+      await writeFileInDir(
+        logger,
+        workflowsWiringMetaFile,
+        serializeWorkflowMeta(
+          workflowsWiringMetaFile,
+          workflowMetaDir,
+          allWorkflowNames,
+          packageMappings,
+          schema?.supportsImportAttributes ?? false,
+          config.externalPackageName
+        )
+      )
+    }
+
+    // Generate workflow registration (meta + DSL workflow registrations)
+    const metaImportPath = getFileImportRelativePath(
+      workflowsWiringFile,
       workflowsWiringMetaFile,
-      serializeWorkflowMeta(workflows.meta)
+      packageMappings
     )
 
-    // Write workflow wirings (imports)
     await writeFileInDir(
       logger,
       workflowsWiringFile,
-      serializeFileImports(
-        'wireWorkflow',
+      serializeWorkflowRegistration(
         workflowsWiringFile,
+        metaImportPath,
+        allWorkflowNames,
         workflows.files,
-        packageMappings
+        workflows.graphFiles,
+        packageMappings,
+        config.externalPackageName
       )
     )
 
-    // Write workflow types
+    // Generate workflow types (DSL + graph helpers in one file)
     const functionTypesImportPath = getFileImportRelativePath(
       workflowTypesFile,
       functionTypesFile,
       packageMappings
     )
+    const rpcMapImportPath = getFileImportRelativePath(
+      workflowTypesFile,
+      config.rpcInternalMapDeclarationFile,
+      packageMappings
+    )
+
     await writeFileInDir(
       logger,
       workflowTypesFile,
-      serializeWorkflowTypes(functionTypesImportPath)
+      serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath)
     )
 
-    // Write workflow map (type-safe client API)
+    // Generate workflow map (I/O types for type-safe client)
+    // Always generate even if empty - RPC map imports WorkflowMap
     await writeFileInDir(
       logger,
       workflowMapDeclarationFile,
@@ -90,6 +184,7 @@ export const pikkuWorkflow: any = pikkuSessionlessFunc<
       )
     )
 
+    // Generate workflow workers if configured
     if (config.workflows) {
       if (config.workflows.singleQueue) {
         const workflowPath = join(config.rootDir, config.workflows.path)
@@ -112,12 +207,12 @@ export const pikkuWorkflow: any = pikkuSessionlessFunc<
       }
     }
 
-    return true
+    return hasWorkflows
   },
   middleware: [
     logCommandInfoAndTime({
-      commandStart: 'Finding Workflows',
-      commandEnd: 'Found Workflows',
+      commandStart: 'Generating Workflows',
+      commandEnd: 'Generated Workflows',
     }),
   ],
 })

package/src/functions/wirings/workflow/serialize-workflow-map.ts

@@ -1,3 +1,6 @@
+/**
+ * Generate workflow map type definitions for type-safe client API
+ */
 import type { WorkflowsMeta } from '@pikku/core/workflow'
 import { serializeImportMap } from '../../../utils/serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
@@ -12,7 +15,8 @@ export const serializeWorkflowMap = (
   workflowsMeta: WorkflowsMeta
 ) => {
   const requiredTypes = new Set<string>()
-  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
+
+  // First generate workflows to collect required types
   const serializedWorkflows = generateWorkflows(
     workflowsMeta,
     functionsMeta,
@@ -20,15 +24,23 @@ export const serializeWorkflowMap = (
     requiredTypes
   )
 
-  const serializedImportMap = serializeImportMap(
-    relativeToPath,
-    packageMappings,
-    typesMap,
-    requiredTypes
-  )
+  // Only generate custom types if we have workflows with types
+  const hasWorkflows = Object.keys(workflowsMeta).length > 0
+  const serializedCustomTypes = hasWorkflows
+    ? generateCustomTypes(typesMap, requiredTypes)
+    : ''
+
+  const serializedImportMap = hasWorkflows
+    ? serializeImportMap(
+        relativeToPath,
+        packageMappings,
+        typesMap,
+        requiredTypes
+      )
+    : ''
 
   return `/**
- * This provides the structure needed for TypeScript to be aware of workflows and their input/output types
+ * Workflow type map with input/output types for each workflow
  */
 
 ${serializedImportMap}
@@ -41,33 +53,16 @@ interface WorkflowHandler<I, O> {
 
 ${serializedWorkflows}
 
-/**
- * Type-safe workflow client API
- */
 export type WorkflowClient<Name extends keyof WorkflowMap> = {
-  /**
-   * Start a new workflow run
-   */
   start: (input: WorkflowMap[Name]['input']) => Promise<{ runId: string }>;
-
-  /**
-   * Get a workflow run by ID
-   */
   getRun: <output extends keyof WorkflowMap[Name]>(runId: string) => Promise<WorkflowMap[Name][output]>;
-
-  /**
-   * Cancel a running workflow
-   */
   cancelRun: (runId: string) => Promise<boolean>;
 }
 
-/**
- * Map of all registered workflows with type-safe client APIs
- */
 export type TypedWorkflowClients = {
   [Name in keyof WorkflowMap]: WorkflowClient<Name>;
 }
-  `
+`
 }
 
 function generateWorkflows(
@@ -76,13 +71,11 @@ function generateWorkflows(
   typesMap: TypesMap,
   requiredTypes: Set<string>
 ) {
-  // Initialize an object to collect workflows
   const workflowsObj: Record<
     string,
     { inputType: string; outputType: string }
   > = {}
 
-  // Iterate through workflow metadata
   for (const [workflowName, { pikkuFuncName }] of Object.entries(
     workflowsMeta
   )) {
@@ -96,27 +89,32 @@ function generateWorkflows(
     const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
     const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
 
-    // Store the input and output types for WorkflowHandler
-    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'void'
-    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'void'
+    let inputType = 'void'
+    if (input) {
+      try {
+        inputType = typesMap.getTypeMeta(input).uniqueName
+      } catch {
+        inputType = input
+      }
+    }
+    let outputType = 'void'
+    if (output) {
+      try {
+        outputType = typesMap.getTypeMeta(output).uniqueName
+      } catch {
+        outputType = output
+      }
+    }
 
     requiredTypes.add(inputType)
     requiredTypes.add(outputType)
-
-    // Add workflow entry
-    workflowsObj[workflowName] = {
-      inputType,
-      outputType,
-    }
+    workflowsObj[workflowName] = { inputType, outputType }
   }
 
-  // Build the Workflows object as a string
   let workflowsStr = 'export type WorkflowMap = {\n'
-
   for (const [workflowName, handler] of Object.entries(workflowsObj)) {
     workflowsStr += `  readonly '${workflowName}': WorkflowHandler<${handler.inputType}, ${handler.outputType}>,\n`
   }
-
   workflowsStr += '};\n'
 
   return workflowsStr

package/src/functions/wirings/workflow/serialize-workflow-meta.ts

@@ -1,16 +1,73 @@
-import { WorkflowsMeta } from '@pikku/core/workflow'
+/**
+ * Generate workflow meta aggregation file that imports individual workflow JSON files
+ * and registers them with pikkuState
+ */
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
-export const serializeWorkflowMeta = (workflowsMeta: WorkflowsMeta) => {
-  const serializedOutput: string[] = []
-  serializedOutput.push("import { pikkuState } from '@pikku/core'")
-  serializedOutput.push(
-    `pikkuState('workflows', 'meta', ${JSON.stringify(workflowsMeta, null, 2)})`
+export const serializeWorkflowMeta = (
+  outputPath: string,
+  metaDir: string,
+  workflowNames: string[],
+  packageMappings: Record<string, string>,
+  supportsImportAttributes: boolean,
+  packageName?: string
+) => {
+  const lines: string[] = []
+
+  if (workflowNames.length === 0) {
+    // Empty meta file - still need to register empty meta
+    lines.push("import { pikkuState } from '@pikku/core'")
+    lines.push(
+      "import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'"
+    )
+    lines.push('')
+    lines.push('const workflowsMeta: SerializedWorkflowGraphs = {}')
+    lines.push('')
+    const packageNameValue = packageName ? `'${packageName}'` : 'null'
+    lines.push(
+      `pikkuState(${packageNameValue}, 'workflows', 'meta', workflowsMeta)`
+    )
+    return lines.join('\n')
+  }
+
+  // Imports
+  lines.push("import { pikkuState } from '@pikku/core'")
+  lines.push(
+    "import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'"
   )
-  const workflowsMetaValues = Object.values(workflowsMeta)
-  if (workflowsMetaValues.length > 0) {
-    serializedOutput.push(
-      `export type WorkflowNames = '${workflowsMetaValues.map((w) => w.workflowName).join("' | '")}'`
+  lines.push('')
+
+  // Import each workflow meta JSON
+  const sortedNames = [...workflowNames].sort()
+  for (const name of sortedNames) {
+    const jsonPath = `${metaDir}/${name}.gen.json`
+    const importPath = getFileImportRelativePath(
+      outputPath,
+      jsonPath,
+      packageMappings
     )
+    const importStatement = supportsImportAttributes
+      ? `import ${name}Meta from '${importPath}' with { type: 'json' }`
+      : `import ${name}Meta from '${importPath}'`
+    lines.push(importStatement)
   }
-  return serializedOutput.join('\n')
+
+  lines.push('')
+
+  // Create aggregated meta object (cast JSON imports to proper types)
+  lines.push('const workflowsMeta = {')
+  for (const name of sortedNames) {
+    lines.push(`  '${name}': ${name}Meta,`)
+  }
+  lines.push('} as SerializedWorkflowGraphs')
+
+  lines.push('')
+
+  // Register meta with pikkuState
+  const packageNameValue = packageName ? `'${packageName}'` : 'null'
+  lines.push(
+    `pikkuState(${packageNameValue}, 'workflows', 'meta', workflowsMeta)`
+  )
+
+  return lines.join('\n')
 }

package/src/functions/wirings/workflow/serialize-workflow-registration.ts

@@ -0,0 +1,83 @@
+/**
+ * Generate workflow runtime registration
+ * Imports meta (which registers with pikkuState) and registers DSL workflows (addWorkflow) and graph workflows (addWorkflowGraph)
+ */
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+
+export const serializeWorkflowRegistration = (
+  outputPath: string,
+  metaImportPath: string,
+  workflowNames: string[],
+  workflowFiles: Map<string, { path: string; exportedName: string }>,
+  graphFiles: Map<string, { path: string; exportedName: string }>,
+  packageMappings: Record<string, string>,
+  _packageName?: string
+) => {
+  const lines: string[] = []
+  const hasWorkflows = workflowNames.length > 0
+  const hasDslWorkflows = workflowFiles.size > 0
+  const hasGraphWorkflows = graphFiles.size > 0
+
+  // Imports
+  const imports: string[] = []
+  if (hasDslWorkflows) {
+    imports.push('addWorkflow')
+  }
+  if (hasGraphWorkflows) {
+    imports.push('addWorkflowGraph')
+  }
+  if (imports.length > 0) {
+    lines.push(`import { ${imports.join(', ')} } from '@pikku/core/workflow'`)
+  }
+
+  // Import meta file (which registers meta with pikkuState)
+  if (hasWorkflows) {
+    lines.push(`import '${metaImportPath}'`)
+  }
+
+  // Import DSL workflow functions
+  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}'`)
+  }
+
+  // Import graph workflow definitions
+  const sortedGraphWorkflows = Array.from(graphFiles.entries()).sort((a, b) =>
+    a[0].localeCompare(b[0])
+  )
+  for (const [, { path, exportedName }] of sortedGraphWorkflows) {
+    const importPath = getFileImportRelativePath(
+      outputPath,
+      path,
+      packageMappings
+    )
+    lines.push(`import { ${exportedName} } from '${importPath}'`)
+  }
+
+  lines.push('')
+
+  // Register DSL workflows
+  for (const [pikkuFuncName, { exportedName }] of sortedWorkflows) {
+    lines.push(`addWorkflow('${pikkuFuncName}', ${exportedName})`)
+  }
+
+  // Register graph workflows
+  for (const [workflowName, { exportedName }] of sortedGraphWorkflows) {
+    lines.push(`addWorkflowGraph('${workflowName}', ${exportedName})`)
+  }
+
+  // Export workflow names type
+  if (hasWorkflows) {
+    lines.push('')
+    lines.push(`export type WorkflowNames = '${workflowNames.join("' | '")}'`)
+  }
+
+  return lines.join('\n')
+}