@pikku/core 0.12.107 → 0.12.111

package/src/wirings/workflow/graph/graph-validation.test.ts

@@ -1,27 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { generateMermaidDiagram } from './graph-validation.js'
-
-describe('generateMermaidDiagram', () => {
-  it('generates valid mermaid output', () => {
-    const nodes = {
-      start: { rpcName: 'toolA', next: 'end' },
-      end: { rpcName: 'toolB' },
-    }
-    const result = generateMermaidDiagram('test-wf', nodes, ['start'])
-    assert.ok(result.includes('graph TD'))
-    assert.ok(result.includes('start([toolA])'))
-    assert.ok(result.includes('end[toolB]'))
-    assert.ok(result.includes('start --> end'))
-  })
-
-  it('shows error edges with dotted lines', () => {
-    const nodes = {
-      start: { rpcName: 'toolA', onError: 'handler' },
-      handler: { rpcName: 'toolB' },
-    }
-    const result = generateMermaidDiagram('test-wf', nodes, ['start'])
-    assert.ok(result.includes('start -.->|error| handler'))
-  })
-})

package/src/wirings/workflow/graph/graph-validation.ts

@@ -1,41 +0,0 @@
-function normalizeTargets(value: unknown): string[] {
-  if (!value) return []
-  if (typeof value === 'string') return [value]
-  if (Array.isArray(value)) return value.filter((v) => typeof v === 'string')
-  if (typeof value === 'object') {
-    const targets: string[] = []
-    for (const v of Object.values(value as Record<string, unknown>)) {
-      targets.push(...normalizeTargets(v))
-    }
-    return targets
-  }
-  return []
-}
-
-export function generateMermaidDiagram(
-  workflowName: string,
-  nodes: Record<string, any>,
-  entryNodeIds: string[]
-): string {
-  const lines: string[] = ['graph TD']
-
-  for (const [nodeId, node] of Object.entries(nodes)) {
-    const label = node.rpcName || nodeId
-    const isEntry = entryNodeIds.includes(nodeId)
-    lines.push(
-      `  ${nodeId}${isEntry ? '([' : '['}${label}${isEntry ? '])' : ']'}`
-    )
-
-    const nextTargets = normalizeTargets(node.next)
-    for (const target of nextTargets) {
-      lines.push(`  ${nodeId} --> ${target}`)
-    }
-
-    const errorTargets = normalizeTargets(node.onError)
-    for (const target of errorTargets) {
-      lines.push(`  ${nodeId} -.->|error| ${target}`)
-    }
-  }
-
-  return lines.join('\n')
-}

package/src/wirings/workflow/graph/template.test.ts

@@ -1,49 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert'
-import { template } from './template.js'
-
-describe('template', () => {
-  test('should parse a simple template with one placeholder', () => {
-    const result = template('Hello $0!', [{ $ref: 'greeting' }])
-    assert.deepStrictEqual(result.$template.parts, ['Hello ', '!'])
-    assert.deepStrictEqual(result.$template.expressions, [{ $ref: 'greeting' }])
-  })
-
-  test('should parse template with multiple placeholders', () => {
-    const result = template('$0 and $1', [{ $ref: 'a' }, { $ref: 'b' }])
-    assert.deepStrictEqual(result.$template.parts, ['', ' and ', ''])
-    assert.strictEqual(result.$template.expressions.length, 2)
-    assert.strictEqual(result.$template.expressions[0].$ref, 'a')
-    assert.strictEqual(result.$template.expressions[1].$ref, 'b')
-  })
-
-  test('should preserve path in references', () => {
-    const result = template('Value: $0', [{ $ref: 'node1', path: 'data.name' }])
-    assert.deepStrictEqual(result.$template.expressions[0], {
-      $ref: 'node1',
-      path: 'data.name',
-    })
-  })
-
-  test('should handle template with no placeholders', () => {
-    const result = template('No placeholders here', [])
-    assert.deepStrictEqual(result.$template.parts, ['No placeholders here'])
-    assert.deepStrictEqual(result.$template.expressions, [])
-  })
-
-  test('should handle out-of-range ref index as unknown', () => {
-    const result = template('$5', [{ $ref: 'a' }])
-    assert.deepStrictEqual(result.$template.expressions[0], { $ref: 'unknown' })
-  })
-
-  test('should handle adjacent placeholders', () => {
-    const result = template('$0$1', [{ $ref: 'a' }, { $ref: 'b' }])
-    assert.deepStrictEqual(result.$template.parts, ['', '', ''])
-    assert.strictEqual(result.$template.expressions.length, 2)
-  })
-
-  test('should omit path when not provided', () => {
-    const result = template('$0', [{ $ref: 'node' }])
-    assert.strictEqual(result.$template.expressions[0].path, undefined)
-  })
-})

package/src/wirings/workflow/graph/template.ts

@@ -1,42 +0,0 @@
-export type TemplateString = {
-  $template: {
-    parts: string[]
-    expressions: Array<{ $ref: string; path?: string }>
-  }
-} & { __brand: 'TemplateString' }
-
-export function template(
-  templateStr: string,
-  refs: Array<{ $ref: string; path?: string }>
-): TemplateString {
-  const parts: string[] = []
-  const expressions: Array<{ $ref: string; path?: string }> = []
-
-  const regex = /\$(\d+)/g
-  let lastIndex = 0
-  let match
-
-  while ((match = regex.exec(templateStr)) !== null) {
-    parts.push(templateStr.slice(lastIndex, match.index))
-
-    const refIndex = parseInt(match[1]!, 10)
-    const refValue = refs[refIndex]
-    if (refValue) {
-      const expr: { $ref: string; path?: string } = { $ref: refValue.$ref }
-      if (refValue.path) {
-        expr.path = refValue.path
-      }
-      expressions.push(expr)
-    } else {
-      expressions.push({ $ref: 'unknown' })
-    }
-
-    lastIndex = regex.lastIndex
-  }
-
-  parts.push(templateStr.slice(lastIndex))
-
-  return {
-    $template: { parts, expressions },
-  } as TemplateString
-}

package/src/wirings/workflow/graph/wire-workflow-graph.ts

@@ -1,39 +0,0 @@
-export interface PikkuWorkflowGraphConfig<
-  FuncMap extends Record<string, string>,
-  T,
-> {
-  /** Keeps the graph in the codebase but out of the build. */
-  disabled?: true
-  /** Unique across the project. It is how the graph is started and how its runs are grouped. */
-  name?: string
-  /** What the graph does, for whoever is reading it rather than editing it. */
-  description?: string
-  /** Filters this graph in and out of a build — see the `tags` option on `pikku all`. It has no effect at runtime. */
-  tags?: string[]
-  /** The graph's steps, keyed by node id, each naming a function. `pikku meta` lists the names available here. */
-  nodes: FuncMap
-  /** Per-node settings — retries, timeouts, the edges between them. */
-  config?: T
-  /** Free text carried onto the rendered graph, for a reader who needs the reasoning the shape cannot show. */
-  notes?: string[]
-}
-
-export interface PikkuWorkflowGraphResult {
-  __type: 'pikkuWorkflowGraph'
-  name?: string
-  description?: string
-  tags?: string[]
-  notes?: string[]
-}
-
-export function pikkuWorkflowGraph<
-  const FuncMap extends Record<string, string>,
->(config: PikkuWorkflowGraphConfig<FuncMap, any>): PikkuWorkflowGraphResult {
-  return {
-    __type: 'pikkuWorkflowGraph',
-    name: config.name,
-    description: config.description,
-    tags: config.tags,
-    notes: config.notes,
-  }
-}

package/src/wirings/workflow/graph/workflow-graph.types.ts

@@ -1,75 +0,0 @@
-import type { TemplateString } from './template.js'
-
-export interface RefValue {
-  __isRef: true
-  nodeId: string
-  path?: string
-}
-
-export const createRef = (nodeId: string, path?: string): RefValue => ({
-  __isRef: true,
-  nodeId,
-  path,
-})
-
-export const isRef = (value: unknown): value is RefValue =>
-  typeof value === 'object' &&
-  value !== null &&
-  '__isRef' in value &&
-  (value as RefValue).__isRef === true
-
-export type RefFn<NodeIds extends string = string> = (
-  nodeId: NodeIds,
-  path?: string
-) => RefValue
-
-export type NextConfig<NodeIds extends string = string> =
-  NodeIds | NodeIds[] | Record<string, NodeIds | NodeIds[]>
-
-export type TemplateFn = (
-  templateStr: string,
-  refs: Array<{ $ref: string; path?: string }>
-) => TemplateString
-
-export type ItemFn = (path?: string) => RefValue
-
-export type ForEachConfig<NodeIds extends string = string> =
-  | NodeIds
-  | RefValue
-  | ((ref: RefFn<NodeIds>) => RefValue)
-
-export type ForEachMode = 'parallel' | 'sequential'
-
-export interface GraphNodeConfig<NodeIds extends string = string> {
-  func: string
-  /**
-   * Run this node once per element of an upstream array. The node's own result
-   * becomes the ordered array of per-item results.
-   */
-  forEach?: ForEachConfig<NodeIds>
-  /** How the per-item instances of a `forEach` node run. Defaults to 'parallel'. */
-  mode?: ForEachMode
-  input?: (
-    ref: RefFn<NodeIds>,
-    template: TemplateFn,
-    $item: ItemFn
-  ) => Record<string, unknown>
-  next?: NextConfig<NodeIds>
-  onError?: NodeIds | NodeIds[]
-  retries?: number
-  retryDelay?: string | number
-  notes?: string
-}
-
-export interface PikkuGraphWire {
-  runId: string
-  graphName: string
-  nodeId: string
-  branch: (key: string) => void
-  setState: (name: string, value: unknown) => Promise<void>
-  getState: () => Promise<Record<string, unknown>>
-}
-
-export interface GraphWireState {
-  branchKey?: string
-}

package/src/wirings/workflow/index.ts

@@ -1,107 +0,0 @@
-export { PikkuWorkflowService } from './pikku-workflow-service.js'
-export {
-  WorkflowCancelledException,
-  WorkflowSuspendedException,
-  WorkflowDispatchException,
-  WorkflowNotFoundError,
-  WorkflowRunNotFoundError,
-  WorkflowApprovalResolvedError,
-  WorkflowStepFunctionMismatchError,
-} from './workflow-errors.js'
-export { DEFAULT_STEP_RETRIES } from './workflow-constants.js'
-export {
-  assertWorkflowRunOwner,
-  WorkflowRunForbiddenError,
-} from './workflow-run-ownership.js'
-export { WorkflowApprovalForbiddenError } from './workflow-approval-policy.js'
-export {
-  streamWorkflowRunStatus,
-  type WorkflowStatusStreamParams,
-} from './workflow-status-stream.js'
-export type {
-  WorkflowRunEngine,
-  WorkflowRunExtension,
-} from './workflow-run-engine.types.js'
-export { deriveInvocationId, uuidv5 } from './workflow-invocation-id.js'
-
-export { isRef } from './graph/workflow-graph.types.js'
-export type { RefValue } from './graph/workflow-graph.types.js'
-
-export {
-  buildRunTimeline,
-  reconstructStateAt,
-  reconstructFinalState,
-} from './run-timeline.js'
-export type { RunTimeline, ReconstructedRunState } from './run-timeline.js'
-
-export { addWorkflow } from './dsl/workflow-runner.js'
-
-export { template, type TemplateString } from './graph/template.js'
-export {
-  pikkuWorkflowGraph,
-  type PikkuWorkflowGraphConfig,
-  type PikkuWorkflowGraphResult,
-} from './graph/wire-workflow-graph.js'
-export type {
-  WorkflowStepInput as WorkflowStepQueueInput,
-  PikkuWorkflowOrchestratorInput,
-  PikkuWorkflowSleeperInput,
-} from './workflow-queue-workers.js'
-
-export type {
-  WorkflowService,
-  WorkflowQueueOptions,
-  WorkflowServiceConfig,
-  WorkflowPlannedStep,
-  WorkflowRunWire,
-  WorkflowStatus,
-  WorkflowVersionStatus,
-  StepStatus,
-  WorkflowRun,
-  WorkflowRunStatus,
-  StepState,
-  WorkflowRunService,
-  WorkflowRunMirror,
-  CoreWorkflow,
-  PikkuWorkflow,
-  ContextVariable,
-  WorkflowContext,
-  WorkflowsMeta,
-  WorkflowsRuntimeMeta,
-} from './workflow.types.js'
-
-export type {
-  WorkflowStepOptions,
-  WorkflowWireDoRPC,
-  WorkflowApprovalOptions,
-  ApprovalOutcome,
-  InputSource,
-  OutputBinding,
-  RpcStepMeta,
-  Condition,
-  BranchStepMeta,
-  ParallelGroupStepMeta,
-  FanoutStepMeta,
-  ReturnStepMeta,
-  InlineStepMeta,
-  SleepStepMeta,
-  CancelStepMeta,
-  SuspendStepMeta,
-  ApprovalStepMeta,
-  SetStepMeta,
-  SwitchCaseMeta,
-  SwitchStepMeta,
-  FilterStepMeta,
-  ArrayPredicateStepMeta,
-  WorkflowStepMeta,
-  WorkflowStepWire,
-  PikkuWorkflowWire,
-} from './workflow.types.js'
-export { createGraph } from './graph/graph-node.js'
-export type {
-  GraphNodeConfig,
-  ForEachConfig,
-  ForEachMode,
-  ItemFn,
-  TemplateFn,
-} from './graph/workflow-graph.types.js'