@llm-dev-ops/agentics-cli 1.4.27 → 1.4.32

package/dist/pipeline/phase4/phases/erp-client-generator.js

@@ -0,0 +1,675 @@
+/**
+ * Phase 4 Pipeline -- Stage 6: ERP Client Generator
+ *
+ * Generates typed ERP surface client code for the resolved implementation
+ * language. Produces request/response type definitions, a client class with
+ * GCP identity token acquisition, and retry/circuit-breaker utilities.
+ *
+ * TypeScript target: class-based client with exponential back-off and
+ *   a circuit breaker guard.
+ * Rust target: reqwest-based async client with equivalent retry logic.
+ *
+ * All generated files carry a "do not edit manually" header.
+ *
+ * Exports:
+ *   - generateErpClient(context) -- pipeline entry point
+ *
+ * Error codes:
+ *   ECLI-P4-060  Missing prerequisite stage output (erp-target-resolution)
+ *   ECLI-P4-061  ERP client file write failure
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createSpan, endSpan, emitSpan } from '../../phase2/telemetry.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const DIR_MODE = 0o700;
+const FILE_MODE = 0o600;
+const GENERATED_HEADER_TS = '// Generated by Phase 4 pipeline — do not edit manually\n';
+const GENERATED_HEADER_RS = '// Generated by Phase 4 pipeline — do not edit manually\n';
+// ============================================================================
+// TypeScript Generation
+// ============================================================================
+/**
+ * Generate TypeScript types.ts with ERP surface request/response interfaces.
+ */
+function tsTypes(erpSystem) {
+    return [
+        GENERATED_HEADER_TS,
+        '/**',
+        ` * ERP surface types for ${erpSystem}.`,
+        ' * These interfaces define the wire format for all ERP integration calls.',
+        ' */',
+        '',
+        '/** Supported ERP system identifiers. */',
+        `export type ErpSystemType = '${erpSystem}';`,
+        '',
+        '/** Request envelope sent to the ERP surface Cloud Function. */',
+        'export interface ErpSurfaceRequest {',
+        '  /** ERP system type. */',
+        '  readonly erp_type: ErpSystemType;',
+        '  /** Integration operation (e.g. "sync", "fetch", "push"). */',
+        '  readonly operation: string;',
+        '  /** Entity type to surface (e.g. "customer", "order", "invoice"). */',
+        '  readonly entity_type: string;',
+        '  /** Query / filter parameters. */',
+        '  readonly query?: Record<string, unknown>;',
+        '  /** Correlation ID for distributed tracing. */',
+        '  readonly correlation_id: string;',
+        '}',
+        '',
+        '/** Response envelope returned by the ERP surface Cloud Function. */',
+        'export interface ErpSurfaceResponse {',
+        '  /** Unique response identifier. */',
+        '  readonly id: string;',
+        '  /** HTTP-like status code of the ERP operation. */',
+        '  readonly status: number;',
+        '  /** Human-readable status message. */',
+        '  readonly message: string;',
+        '  /** Response payload (entity data or error details). */',
+        '  readonly data: unknown;',
+        '  /** Echo of the correlation ID from the request. */',
+        '  readonly correlation_id: string;',
+        '  /** ISO-8601 timestamp of when the response was generated. */',
+        '  readonly timestamp: string;',
+        '}',
+        '',
+    ].join('\n');
+}
+/**
+ * Generate TypeScript client.ts with ErpSurfaceClient class.
+ */
+function tsClient() {
+    return [
+        GENERATED_HEADER_TS,
+        `import type { ErpSurfaceRequest, ErpSurfaceResponse } from './types.js';`,
+        `import { withRetry } from './retry.js';`,
+        '',
+        'const GCP_METADATA_TOKEN_URL =',
+        '  \'http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity\';',
+        'const REQUEST_TIMEOUT_MS = 30_000;',
+        '',
+        '/**',
+        ' * Client for the ERP surface Cloud Function.',
+        ' *',
+        ' * Acquires a GCP service account identity token from the metadata server,',
+        ' * attaches it as a Bearer token, and dispatches requests with retry logic.',
+        ' */',
+        'export class ErpSurfaceClient {',
+        '  private readonly baseUrl: string;',
+        '  private readonly serviceAccountEmail: string;',
+        '',
+        '  constructor(baseUrl: string, serviceAccountEmail: string) {',
+        '    this.baseUrl = baseUrl.replace(/\\/$/, \'\');',
+        '    this.serviceAccountEmail = serviceAccountEmail;',
+        '  }',
+        '',
+        '  /**',
+        '   * Push an entity to the ERP surface.',
+        '   *',
+        '   * Automatically retries with exponential back-off on transient errors.',
+        '   *',
+        '   * @param request - The ERP surface request payload',
+        '   * @returns The ERP surface response envelope',
+        '   */',
+        '  async pushEntity(request: ErpSurfaceRequest): Promise<ErpSurfaceResponse> {',
+        '    return withRetry(async () => {',
+        '      const token = await this.getIdentityToken();',
+        '',
+        '      const controller = new AbortController();',
+        '      const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);',
+        '',
+        '      try {',
+        '        const response = await fetch(`${this.baseUrl}/v1/erpsurface`, {',
+        '          method: \'POST\',',
+        '          headers: {',
+        '            \'Content-Type\': \'application/json\',',
+        '            \'Authorization\': `Bearer ${token}`,',
+        '          },',
+        '          body: JSON.stringify(request),',
+        '          signal: controller.signal,',
+        '        });',
+        '',
+        '        if (!response.ok) {',
+        '          throw new Error(',
+        '            `ERP surface returned HTTP ${response.status}: ${await response.text()}`,',
+        '          );',
+        '        }',
+        '',
+        '        return response.json() as Promise<ErpSurfaceResponse>;',
+        '      } finally {',
+        '        clearTimeout(timeoutId);',
+        '      }',
+        '    });',
+        '  }',
+        '',
+        '  /**',
+        '   * Fetch a GCP identity token from the instance metadata server.',
+        '   * Passes the service account email as the `audience` query parameter.',
+        '   */',
+        '  private async getIdentityToken(): Promise<string> {',
+        '    const url = new URL(GCP_METADATA_TOKEN_URL);',
+        '    url.searchParams.set(\'audience\', this.serviceAccountEmail);',
+        '',
+        '    const response = await fetch(url.toString(), {',
+        '      headers: { \'Metadata-Flavor\': \'Google\' },',
+        '    });',
+        '',
+        '    if (!response.ok) {',
+        '      throw new Error(',
+        '        `Failed to obtain GCP identity token: HTTP ${response.status}`,',
+        '      );',
+        '    }',
+        '',
+        '    return response.text();',
+        '  }',
+        '}',
+        '',
+    ].join('\n');
+}
+/**
+ * Generate TypeScript retry.ts with exponential back-off and circuit breaker.
+ */
+function tsRetry() {
+    return [
+        GENERATED_HEADER_TS,
+        '/** Configuration for the exponential back-off retry policy. */',
+        'export interface RetryConfig {',
+        '  /** Maximum number of retry attempts (default: 3). */',
+        '  readonly maxAttempts: number;',
+        '  /** Initial back-off delay in milliseconds (default: 1000). */',
+        '  readonly initialDelayMs: number;',
+        '  /** Multiplier applied to delay on each attempt (default: 2). */',
+        '  readonly multiplier: number;',
+        '}',
+        '',
+        'const DEFAULT_RETRY_CONFIG: RetryConfig = {',
+        '  maxAttempts: 3,',
+        '  initialDelayMs: 1_000,',
+        '  multiplier: 2,',
+        '};',
+        '',
+        '/**',
+        ' * Execute an async operation with exponential back-off retry.',
+        ' *',
+        ' * Retry schedule (default config): 1 s → 2 s → 4 s (3 attempts total).',
+        ' *',
+        ' * @param fn     - The async operation to attempt',
+        ' * @param config - Optional retry configuration override',
+        ' */',
+        'export async function withRetry<T>(',
+        '  fn: () => Promise<T>,',
+        '  config: RetryConfig = DEFAULT_RETRY_CONFIG,',
+        '): Promise<T> {',
+        '  let lastError: unknown;',
+        '  let delayMs = config.initialDelayMs;',
+        '',
+        '  for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {',
+        '    try {',
+        '      return await fn();',
+        '    } catch (err) {',
+        '      lastError = err;',
+        '      if (attempt < config.maxAttempts) {',
+        '        await sleep(delayMs);',
+        '        delayMs *= config.multiplier;',
+        '      }',
+        '    }',
+        '  }',
+        '',
+        '  throw lastError;',
+        '}',
+        '',
+        'function sleep(ms: number): Promise<void> {',
+        '  return new Promise((resolve) => setTimeout(resolve, ms));',
+        '}',
+        '',
+        '/**',
+        ' * Circuit breaker that opens after a configurable failure threshold and',
+        ' * resets after a configurable timeout.',
+        ' */',
+        'export class CircuitBreaker {',
+        '  private failures = 0;',
+        '  private openedAt: number | null = null;',
+        '',
+        '  constructor(',
+        '    private readonly threshold: number = 5,',
+        '    private readonly resetTimeoutMs: number = 60_000,',
+        '  ) {}',
+        '',
+        '  /** Returns true if the circuit is currently open (tripped). */',
+        '  get isOpen(): boolean {',
+        '    if (this.openedAt === null) return false;',
+        '    if (Date.now() - this.openedAt >= this.resetTimeoutMs) {',
+        '      // Half-open: allow next attempt to probe the service',
+        '      this.openedAt = null;',
+        '      this.failures = 0;',
+        '      return false;',
+        '    }',
+        '    return true;',
+        '  }',
+        '',
+        '  /**',
+        '   * Execute an async operation under the circuit breaker.',
+        '   * Throws immediately if the circuit is open.',
+        '   */',
+        '  async execute<T>(fn: () => Promise<T>): Promise<T> {',
+        '    if (this.isOpen) {',
+        '      throw new Error(\'Circuit breaker is open — downstream service unavailable\');',
+        '    }',
+        '    try {',
+        '      const result = await fn();',
+        '      this.failures = 0;',
+        '      return result;',
+        '    } catch (err) {',
+        '      this.failures++;',
+        '      if (this.failures >= this.threshold) {',
+        '        this.openedAt = Date.now();',
+        '      }',
+        '      throw err;',
+        '    }',
+        '  }',
+        '',
+        '  /** Reset the circuit breaker to closed state. */',
+        '  reset(): void {',
+        '    this.failures = 0;',
+        '    this.openedAt = null;',
+        '  }',
+        '}',
+        '',
+    ].join('\n');
+}
+// ============================================================================
+// Rust Generation
+// ============================================================================
+/**
+ * Generate Rust types.rs with ERP surface request/response structs.
+ */
+function rustTypes(erpSystem) {
+    return [
+        GENERATED_HEADER_RS,
+        `//! ERP surface types for ${erpSystem}.`,
+        '',
+        'use serde::{Deserialize, Serialize};',
+        'use std::collections::HashMap;',
+        '',
+        '/// Request envelope sent to the ERP surface Cloud Function.',
+        '#[derive(Debug, Clone, Serialize, Deserialize)]',
+        'pub struct ErpSurfaceRequest {',
+        `    /// ERP system type (e.g. "${erpSystem}").`,
+        '    pub erp_type: String,',
+        '    /// Integration operation (e.g. "sync", "fetch", "push").',
+        '    pub operation: String,',
+        '    /// Entity type to surface (e.g. "customer", "order", "invoice").',
+        '    pub entity_type: String,',
+        '    /// Query / filter parameters.',
+        '    #[serde(skip_serializing_if = "Option::is_none")]',
+        '    pub query: Option<HashMap<String, serde_json::Value>>,',
+        '    /// Correlation ID for distributed tracing.',
+        '    pub correlation_id: String,',
+        '}',
+        '',
+        '/// Response envelope returned by the ERP surface Cloud Function.',
+        '#[derive(Debug, Clone, Serialize, Deserialize)]',
+        'pub struct ErpSurfaceResponse {',
+        '    /// Unique response identifier.',
+        '    pub id: String,',
+        '    /// HTTP-like status code of the ERP operation.',
+        '    pub status: u16,',
+        '    /// Human-readable status message.',
+        '    pub message: String,',
+        '    /// Response payload.',
+        '    pub data: serde_json::Value,',
+        '    /// Echo of the correlation ID from the request.',
+        '    pub correlation_id: String,',
+        '    /// ISO-8601 timestamp.',
+        '    pub timestamp: String,',
+        '}',
+        '',
+    ].join('\n');
+}
+/**
+ * Generate Rust client.rs with reqwest-based ErpSurfaceClient.
+ */
+function rustClient() {
+    return [
+        GENERATED_HEADER_RS,
+        'use crate::erp_client::types::{ErpSurfaceRequest, ErpSurfaceResponse};',
+        'use crate::erp_client::retry::with_retry;',
+        '',
+        'const GCP_METADATA_TOKEN_URL: &str =',
+        '    "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity";',
+        'const REQUEST_TIMEOUT_SECS: u64 = 30;',
+        '',
+        '/// Client for the ERP surface Cloud Function.',
+        'pub struct ErpSurfaceClient {',
+        '    base_url: String,',
+        '    service_account_email: String,',
+        '    http: reqwest::Client,',
+        '}',
+        '',
+        'impl ErpSurfaceClient {',
+        '    pub fn new(base_url: String, service_account_email: String) -> Self {',
+        '        let http = reqwest::Client::builder()',
+        '            .timeout(std::time::Duration::from_secs(REQUEST_TIMEOUT_SECS))',
+        '            .build()',
+        '            .expect("Failed to build HTTP client");',
+        '        let base_url = base_url.trim_end_matches(\'/\').to_string();',
+        '        Self { base_url, service_account_email, http }',
+        '    }',
+        '',
+        '    /// Push an entity to the ERP surface with retry on transient errors.',
+        '    pub async fn push_entity(',
+        '        &self,',
+        '        request: ErpSurfaceRequest,',
+        '    ) -> Result<ErpSurfaceResponse, Box<dyn std::error::Error>> {',
+        '        let client = self;',
+        '        with_retry(|| async {',
+        '            let token = client.get_identity_token().await?;',
+        '            let url = format!("{}/v1/erpsurface", client.base_url);',
+        '            let response = client.http',
+        '                .post(&url)',
+        '                .header("Authorization", format!("Bearer {}", token))',
+        '                .header("Content-Type", "application/json")',
+        '                .json(&request)',
+        '                .send()',
+        '                .await?;',
+        '',
+        '            if !response.status().is_success() {',
+        '                let status = response.status().as_u16();',
+        '                let body = response.text().await.unwrap_or_default();',
+        '                return Err(format!("ERP surface returned HTTP {}: {}", status, body).into());',
+        '            }',
+        '',
+        '            Ok(response.json::<ErpSurfaceResponse>().await?)',
+        '        }).await',
+        '    }',
+        '',
+        '    /// Fetch a GCP identity token from the instance metadata server.',
+        '    async fn get_identity_token(&self) -> Result<String, Box<dyn std::error::Error>> {',
+        '        let url = format!("{}?audience={}", GCP_METADATA_TOKEN_URL, self.service_account_email);',
+        '        let token = self.http',
+        '            .get(&url)',
+        '            .header("Metadata-Flavor", "Google")',
+        '            .send()',
+        '            .await?',
+        '            .error_for_status()?',
+        '            .text()',
+        '            .await?;',
+        '        Ok(token)',
+        '    }',
+        '}',
+        '',
+    ].join('\n');
+}
+/**
+ * Generate Rust retry.rs with exponential back-off and circuit breaker.
+ */
+function rustRetry() {
+    return [
+        GENERATED_HEADER_RS,
+        'use std::future::Future;',
+        'use std::sync::{Arc, Mutex};',
+        'use std::time::{Duration, Instant};',
+        '',
+        '/// Configuration for the exponential back-off retry policy.',
+        '#[derive(Debug, Clone)]',
+        'pub struct RetryConfig {',
+        '    /// Maximum number of retry attempts.',
+        '    pub max_attempts: u32,',
+        '    /// Initial back-off delay.',
+        '    pub initial_delay: Duration,',
+        '    /// Multiplier applied to delay on each attempt.',
+        '    pub multiplier: u32,',
+        '}',
+        '',
+        'impl Default for RetryConfig {',
+        '    fn default() -> Self {',
+        '        Self {',
+        '            max_attempts: 3,',
+        '            initial_delay: Duration::from_secs(1),',
+        '            multiplier: 2,',
+        '        }',
+        '    }',
+        '}',
+        '',
+        '/// Execute an async operation with exponential back-off retry.',
+        '////',
+        '/// Retry schedule (default config): 1 s → 2 s → 4 s (3 attempts total).',
+        'pub async fn with_retry<F, Fut, T, E>(',
+        '    mut f: F,',
+        ') -> Result<T, E>',
+        'where',
+        '    F: FnMut() -> Fut,',
+        '    Fut: Future<Output = Result<T, E>>,',
+        '{',
+        '    let config = RetryConfig::default();',
+        '    let mut delay = config.initial_delay;',
+        '    let mut last_err: Option<E> = None;',
+        '',
+        '    for attempt in 1..=config.max_attempts {',
+        '        match f().await {',
+        '            Ok(value) => return Ok(value),',
+        '            Err(err) => {',
+        '                last_err = Some(err);',
+        '                if attempt < config.max_attempts {',
+        '                    tokio::time::sleep(delay).await;',
+        '                    delay *= config.multiplier;',
+        '                }',
+        '            }',
+        '        }',
+        '    }',
+        '',
+        '    Err(last_err.unwrap())',
+        '}',
+        '',
+        '/// Circuit breaker state.',
+        '#[derive(Debug)]',
+        'struct CircuitBreakerState {',
+        '    failures: u32,',
+        '    opened_at: Option<Instant>,',
+        '}',
+        '',
+        '/// Circuit breaker that opens after a configurable failure threshold.',
+        '#[derive(Debug, Clone)]',
+        'pub struct CircuitBreaker {',
+        '    threshold: u32,',
+        '    reset_timeout: Duration,',
+        '    state: Arc<Mutex<CircuitBreakerState>>,',
+        '}',
+        '',
+        'impl CircuitBreaker {',
+        '    pub fn new(threshold: u32, reset_timeout_ms: u64) -> Self {',
+        '        Self {',
+        '            threshold,',
+        '            reset_timeout: Duration::from_millis(reset_timeout_ms),',
+        '            state: Arc::new(Mutex::new(CircuitBreakerState { failures: 0, opened_at: None })),',
+        '        }',
+        '    }',
+        '',
+        '    /// Execute an async operation under the circuit breaker.',
+        '    pub async fn execute<F, Fut, T>(&self, f: F) -> Result<T, Box<dyn std::error::Error>>',
+        '    where',
+        '        F: FnOnce() -> Fut,',
+        '        Fut: Future<Output = Result<T, Box<dyn std::error::Error>>>,',
+        '    {',
+        '        {',
+        '            let mut state = self.state.lock().unwrap();',
+        '            if let Some(opened_at) = state.opened_at {',
+        '                if opened_at.elapsed() < self.reset_timeout {',
+        '                    return Err("Circuit breaker is open — downstream service unavailable".into());',
+        '                }',
+        '                // Half-open: reset and probe',
+        '                state.failures = 0;',
+        '                state.opened_at = None;',
+        '            }',
+        '        }',
+        '',
+        '        match f().await {',
+        '            Ok(value) => {',
+        '                self.state.lock().unwrap().failures = 0;',
+        '                Ok(value)',
+        '            }',
+        '            Err(err) => {',
+        '                let mut state = self.state.lock().unwrap();',
+        '                state.failures += 1;',
+        '                if state.failures >= self.threshold {',
+        '                    state.opened_at = Some(Instant::now());',
+        '                }',
+        '                Err(err)',
+        '            }',
+        '        }',
+        '    }',
+        '}',
+        '',
+        'impl Default for CircuitBreaker {',
+        '    fn default() -> Self {',
+        '        Self::new(5, 60_000)',
+        '    }',
+        '}',
+        '',
+    ].join('\n');
+}
+// ============================================================================
+// File Writing
+// ============================================================================
+/**
+ * Write a client file to disk, creating parent directories as needed.
+ */
+function writeClientFile(absPath, content) {
+    const dir = absPath.substring(0, absPath.lastIndexOf('/'));
+    mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+    try {
+        writeFileSync(absPath, content, { encoding: 'utf-8', mode: FILE_MODE });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`ECLI-P4-061: Failed to write ERP client file ${absPath}: ${message}`);
+    }
+}
+// ============================================================================
+// Public: Pipeline Entry Point
+// ============================================================================
+/**
+ * Stage 6 entry point: generate typed ERP surface client code for the
+ * resolved implementation language.
+ *
+ * Reads ERPResolution from context.stageOutputs.get('erp-target-resolution')
+ * and writes client files to phase4/project/src/erp-client/.
+ *
+ * @param context - The Phase 4 pipeline context
+ * @returns Stage output describing success or failure
+ */
+export function generateErpClient(context) {
+    const startTime = Date.now();
+    const rootSpan = createSpan('erp-client-generation', 'generate-erp-client', {
+        phase4Dir: context.phase4Dir,
+        traceId: context.traceId,
+    });
+    try {
+        // Verify ERP target resolution completed
+        const erpStage = context.stageOutputs.get('erp-target-resolution');
+        if (!erpStage || erpStage.status !== 'completed') {
+            throw new Error('ECLI-P4-060: ERP target resolution not available on context. ' +
+                'Ensure the erp-target-resolution stage completed successfully before running erp-client-generation.');
+        }
+        const erpResolution = erpStage.data;
+        const erpSystem = erpResolution.erpSystem;
+        // Resolve implementation language
+        const language = context.phase3Artifacts.implementationLanguage;
+        const isTs = language === 'typescript';
+        // Output directory: phase4/project/src/erp-client/
+        const clientDir = join(context.phase4Dir, 'project', 'src', 'erp-client');
+        mkdirSync(clientDir, { recursive: true, mode: DIR_MODE });
+        const clientFiles = [];
+        const writtenPaths = [];
+        const genSpan = createSpan('erp-client-generation', 'generate-files', { language, erpSystem }, rootSpan.spanId);
+        if (isTs) {
+            const files = [
+                { name: 'types.ts', content: tsTypes(erpSystem) },
+                { name: 'client.ts', content: tsClient() },
+                { name: 'retry.ts', content: tsRetry() },
+            ];
+            for (const file of files) {
+                const absPath = join(clientDir, file.name);
+                writeClientFile(absPath, file.content);
+                const relPath = `project/src/erp-client/${file.name}`;
+                clientFiles.push({ relativePath: relPath, content: file.content, kind: 'erp-client' });
+                writtenPaths.push(absPath);
+            }
+        }
+        else {
+            // Rust: write to erp_client subdirectory convention
+            const rustClientDir = join(context.phase4Dir, 'project', 'src', 'erp_client');
+            mkdirSync(rustClientDir, { recursive: true, mode: DIR_MODE });
+            const files = [
+                { name: 'types.rs', content: rustTypes(erpSystem) },
+                { name: 'client.rs', content: rustClient() },
+                { name: 'retry.rs', content: rustRetry() },
+            ];
+            for (const file of files) {
+                const absPath = join(rustClientDir, file.name);
+                writeClientFile(absPath, file.content);
+                const relPath = `project/src/erp_client/${file.name}`;
+                clientFiles.push({ relativePath: relPath, content: file.content, kind: 'erp-client' });
+                writtenPaths.push(absPath);
+            }
+            // mod.rs for Rust module system
+            const modContent = [
+                GENERATED_HEADER_RS,
+                'pub mod client;',
+                'pub mod retry;',
+                'pub mod types;',
+                '',
+            ].join('\n');
+            const modPath = join(rustClientDir, 'mod.rs');
+            writeClientFile(modPath, modContent);
+            clientFiles.push({ relativePath: 'project/src/erp_client/mod.rs', content: modContent, kind: 'erp-client' });
+            writtenPaths.push(modPath);
+        }
+        // Integration endpoints: request types + response types + retry + circuit breaker
+        const endpointCount = 3;
+        const finalGenSpan = endSpan(genSpan, 'ok', { filesGenerated: writtenPaths.length, endpointCount });
+        emitSpan(finalGenSpan);
+        const finalRootSpan = endSpan(rootSpan, 'ok', {
+            language,
+            erpSystem,
+            filesGenerated: writtenPaths.length,
+            endpointCount,
+        });
+        emitSpan(finalRootSpan);
+        const timing = Date.now() - startTime;
+        const output = {
+            stage: 'erp-client-generation',
+            status: 'completed',
+            data: {
+                files: clientFiles,
+                endpointCount,
+            },
+            artifacts: writtenPaths,
+            timing,
+            summary: `Generated ERP client (${language}) for ${erpSystem}: ` +
+                `${writtenPaths.length} files, ${endpointCount} endpoint types ` +
+                `(${timing}ms)`,
+        };
+        context.stageOutputs.set('erp-client-generation', output);
+        return output;
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const finalRootSpan = endSpan(rootSpan, 'error', { error: errorMessage });
+        emitSpan(finalRootSpan);
+        const timing = Date.now() - startTime;
+        const output = {
+            stage: 'erp-client-generation',
+            status: 'failed',
+            data: { error: errorMessage },
+            artifacts: [],
+            timing,
+            summary: `ERP client generation failed: ${errorMessage}`,
+        };
+        context.stageOutputs.set('erp-client-generation', output);
+        return output;
+    }
+}
+//# sourceMappingURL=erp-client-generator.js.map