@llm-dev-ops/agentics-cli 1.4.87 → 1.4.90

package/dist/erp-client/client.js

@@ -0,0 +1,235 @@
+// Generated by Phase 4 pipeline — do not edit manually
+import { InforMapper } from './mapper.js';
+import { withRetry, CircuitBreaker } 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;
+// ============================================================================
+// InforClient — Anti-Corruption Layer
+// ============================================================================
+export class InforClient {
+    baseUrl;
+    serviceAccountEmail;
+    mapper;
+    breaker;
+    governance;
+    audit;
+    syncQueue = [];
+    recentErrors = [];
+    lastSuccessfulSync = null;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.serviceAccountEmail = config.serviceAccountEmail;
+        this.governance = config.governance;
+        this.mapper = new InforMapper(config.governance);
+        this.breaker = new CircuitBreaker(config.circuitBreakerThreshold ?? 5, config.circuitBreakerResetMs ?? 60_000);
+        this.audit = config.audit ?? null;
+    }
+    // --------------------------------------------------------------------------
+    // Governance Guard
+    // --------------------------------------------------------------------------
+    assertWriteAllowed(operation) {
+        if (this.governance.read_only) {
+            throw new Error(`Governance: write operation '${operation}' blocked — read_only mode is enabled`);
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Domain Operations (ACL boundary)
+    // --------------------------------------------------------------------------
+    async createTransferOrder(domain, correlationId) {
+        this.assertWriteAllowed('createTransferOrder');
+        const wire = this.mapper.toTransferOrder(domain);
+        return this.executeWithFallback('createTransferOrder', domain.id, correlationId, async () => {
+            return this.post('/M3/m3api-rest/v2/execute/MMS850MI/AddTransferOrder', wire, correlationId);
+        }, wire);
+    }
+    async createPurchaseOrder(domain, correlationId) {
+        this.assertWriteAllowed('createPurchaseOrder');
+        const wire = this.mapper.toPurchaseOrder(domain);
+        return this.executeWithFallback('createPurchaseOrder', domain.id, correlationId, async () => {
+            return this.post('/M3/m3api-rest/v2/execute/PPS200MI/AddPurchaseOrder', wire, correlationId);
+        }, wire);
+    }
+    async getInventoryBalance(subsidiary, location, item, correlationId) {
+        await this.auditBefore('getInventoryBalance', 'inventory', correlationId, { subsidiary, location, item });
+        try {
+            const response = await this.breaker.execute(() => withRetry(() => this.get(`/M3/m3api-rest/v2/execute/MMS200MI/GetItemBalance?subsidiary=${encodeURIComponent(subsidiary)}&location=${encodeURIComponent(location)}&item=${encodeURIComponent(item)}`, correlationId)));
+            this.lastSuccessfulSync = new Date().toISOString();
+            await this.auditAfter('getInventoryBalance', 'inventory', correlationId, response);
+            if (response.status === 200 && response.data) {
+                return this.mapper.fromInventoryBalance(response.data);
+            }
+            return null;
+        }
+        catch (err) {
+            this.recordError('getInventoryBalance', err);
+            return null;
+        }
+    }
+    async updateItemReceipt(domain, transferNsId, correlationId) {
+        this.assertWriteAllowed('updateItemReceipt');
+        const wire = this.mapper.toItemReceipt(domain, transferNsId);
+        return this.executeWithFallback('updateItemReceipt', domain.transfer_id, correlationId, async () => {
+            return this.post('/M3/m3api-rest/v2/execute/PPS300MI/AddReceipt', wire, correlationId);
+        }, wire);
+    }
+    // --------------------------------------------------------------------------
+    // Sync Queue & Status
+    // --------------------------------------------------------------------------
+    getSyncStatus() {
+        return {
+            last_successful_sync: this.lastSuccessfulSync,
+            pending_queue_depth: this.syncQueue.length,
+            circuit_breaker_state: this.breaker.state,
+            recent_errors: this.recentErrors.slice(-20),
+        };
+    }
+    getPendingQueue() {
+        return this.syncQueue;
+    }
+    async drainSyncQueue() {
+        let processed = 0;
+        let failed = 0;
+        const remaining = [];
+        for (const entry of this.syncQueue) {
+            try {
+                await this.breaker.execute(() => withRetry(() => this.post(this.operationToPath(entry.operation), entry.payload, entry.id)));
+                processed++;
+                this.lastSuccessfulSync = new Date().toISOString();
+            }
+            catch (err) {
+                failed++;
+                remaining.push({
+                    ...entry,
+                    retry_count: entry.retry_count + 1,
+                    last_error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        this.syncQueue.length = 0;
+        this.syncQueue.push(...remaining);
+        return { processed, failed };
+    }
+    // --------------------------------------------------------------------------
+    // Internal: HTTP Transport
+    // --------------------------------------------------------------------------
+    async post(path, body, correlationId) {
+        const token = await this.getIdentityToken();
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const response = await fetch(`${this.baseUrl}${path}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${token}`,
+                    'X-Correlation-ID': correlationId,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`Infor returned HTTP ${response.status}: ${await response.text()}`);
+            }
+            return response.json();
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async get(path, correlationId) {
+        const token = await this.getIdentityToken();
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const response = await fetch(`${this.baseUrl}${path}`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'X-Correlation-ID': correlationId,
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`Infor returned HTTP ${response.status}: ${await response.text()}`);
+            }
+            return response.json();
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async getIdentityToken() {
+        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();
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Fallback & Queue
+    // --------------------------------------------------------------------------
+    async executeWithFallback(operation, entityId, correlationId, fn, payload) {
+        await this.auditBefore(operation, entityId, correlationId, payload);
+        try {
+            const result = await this.breaker.execute(() => withRetry(fn));
+            this.lastSuccessfulSync = new Date().toISOString();
+            await this.auditAfter(operation, entityId, correlationId, result);
+            return result;
+        }
+        catch (err) {
+            this.recordError(operation, err);
+            // Queue for retry when ERP is unreachable
+            this.syncQueue.push({
+                id: correlationId,
+                operation,
+                payload,
+                created_at: new Date().toISOString(),
+                retry_count: 0,
+                last_error: err instanceof Error ? err.message : String(err),
+            });
+            // Return a queued response so domain services can continue
+            return {
+                id: correlationId,
+                status: 202,
+                message: `Queued for sync — Infor temporarily unreachable`,
+                data: { queued: true, operation, entity_id: entityId },
+                correlation_id: correlationId,
+                timestamp: new Date().toISOString(),
+            };
+        }
+    }
+    recordError(operation, err) {
+        this.recentErrors.push({
+            timestamp: new Date().toISOString(),
+            operation,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        if (this.recentErrors.length > 100)
+            this.recentErrors.splice(0, this.recentErrors.length - 100);
+    }
+    operationToPath(operation) {
+        const paths = {
+            createTransferOrder: '/M3/m3api-rest/v2/execute/MMS850MI/AddTransferOrder',
+            createPurchaseOrder: '/M3/m3api-rest/v2/execute/PPS200MI/AddPurchaseOrder',
+            updateItemReceipt: '/M3/m3api-rest/v2/execute/PPS300MI/AddReceipt',
+        };
+        return paths[operation] ?? '/M3/m3api-rest/v2/execute/ENTITY';
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Audit Logging
+    // --------------------------------------------------------------------------
+    async auditBefore(operation, entityId, correlationId, payload) {
+        if (!this.governance.audit_enabled || !this.audit)
+            return;
+        await this.audit.log('infor_cloudsuite_call', entityId, `${operation}:before`, correlationId, payload);
+    }
+    async auditAfter(operation, entityId, correlationId, result) {
+        if (!this.governance.audit_enabled || !this.audit)
+            return;
+        await this.audit.log('infor_cloudsuite_call', entityId, `${operation}:after`, correlationId, result);
+    }
+}

package/dist/erp-client/mapper.d.ts

@@ -0,0 +1,9 @@
+import type { DomainTransferOrder, DomainPurchaseOrder, DomainInventoryBalance, DomainItemReceipt, InforTransferOrder, InforPurchaseOrder, InforInventoryBalance, InforItemReceipt, GovernanceConfig } from './types.js';
+export declare class InforMapper {
+    private readonly governance;
+    constructor(governance: GovernanceConfig);
+    toTransferOrder(domain: DomainTransferOrder): InforTransferOrder;
+    toPurchaseOrder(domain: DomainPurchaseOrder): InforPurchaseOrder;
+    toItemReceipt(domain: DomainItemReceipt, transferNsId: string): InforItemReceipt;
+    fromInventoryBalance(ns: InforInventoryBalance): DomainInventoryBalance;
+}

package/dist/erp-client/mapper.js

@@ -0,0 +1,116 @@
+// Generated by Phase 4 pipeline — do not edit manually
+// ============================================================================
+// PII Redaction
+// ============================================================================
+const PII_PATTERNS = [
+    /\b\d{3}-\d{2}-\d{4}\b/g, // SSN
+    /\b[A-Z]{2}\d{6,9}\b/g, // Passport
+    /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, // Credit card
+    /patient[_\s]?(?:id|name|mrn)/gi, // Patient identifiers
+];
+function redactPii(value) {
+    let result = value;
+    for (const pattern of PII_PATTERNS) {
+        result = result.replace(pattern, '[REDACTED]');
+    }
+    return result;
+}
+function redactObject(obj, governance) {
+    if (!governance.pii_redaction)
+        return obj;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === 'string') {
+            result[key] = redactPii(value);
+        }
+        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            result[key] = redactObject(value, governance);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+// ============================================================================
+// InforMapper — Domain ↔ Wire Type Translation
+// ============================================================================
+export class InforMapper {
+    governance;
+    constructor(governance) {
+        this.governance = governance;
+    }
+    // --------------------------------------------------------------------------
+    // Domain → Infor (outbound)
+    // --------------------------------------------------------------------------
+    toTransferOrder(domain) {
+        const wire = {
+            subsidiary: { id: '1' },
+            location: { id: domain.from_facility },
+            transferLocation: { id: domain.to_facility },
+            memo: `Transfer ${domain.sku} — priority: ${domain.priority}`,
+            item: {
+                items: [{
+                        item: { id: domain.sku },
+                        quantity: domain.quantity,
+                        units: { id: '1' },
+                    }],
+            },
+        };
+        if (this.governance.pii_redaction) {
+            return redactObject(wire, this.governance);
+            {
+                wp;
+            }
+            TransferOrder;
+        }
+        return wire;
+    }
+    toPurchaseOrder(domain) {
+        const wire = {
+            entity: { id: domain.vendor_id },
+            subsidiary: { id: '1' },
+            location: { id: domain.facility_id },
+            memo: `PO for ${domain.sku} — qty: ${domain.quantity}`,
+            item: {
+                items: [{
+                        item: { id: domain.sku },
+                        quantity: domain.quantity,
+                    }],
+            },
+        };
+        if (this.governance.pii_redaction) {
+            return redactObject(wire, this.governance);
+            {
+                wp;
+            }
+            PurchaseOrder;
+        }
+        return wire;
+    }
+    toItemReceipt(domain, transferNsId) {
+        return {
+            createdFrom: { id: transferNsId },
+            subsidiary: { id: '1' },
+            item: {
+                items: [{
+                        item: { id: domain.sku },
+                        quantity: domain.quantity_received,
+                        location: { id: domain.facility_id },
+                    }],
+            },
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Infor → Domain (inbound)
+    // --------------------------------------------------------------------------
+    fromInventoryBalance(ns) {
+        return {
+            facility_id: ns.location.id,
+            sku: ns.item.id,
+            quantity: ns.quantityAvailable,
+            unit_of_measure: 'EA',
+            last_synced_at: ns.lastModifiedDate,
+        };
+    }
+}

package/dist/erp-client/retry.d.ts

@@ -0,0 +1,17 @@
+export interface RetryConfig {
+    readonly maxAttempts: number;
+    readonly initialDelayMs: number;
+    readonly multiplier: number;
+}
+export declare function withRetry<T>(fn: () => Promise<T>, config?: RetryConfig): Promise<T>;
+export declare class CircuitBreaker {
+    private readonly threshold;
+    private readonly resetTimeoutMs;
+    private failures;
+    private openedAt;
+    constructor(threshold?: number, resetTimeoutMs?: number);
+    get state(): 'closed' | 'open' | 'half-open';
+    get isOpen(): boolean;
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    reset(): void;
+}

package/dist/erp-client/retry.js

@@ -0,0 +1,74 @@
+// Generated by Phase 4 pipeline — do not edit manually
+const DEFAULT_RETRY_CONFIG = {
+    maxAttempts: 3,
+    initialDelayMs: 1_000,
+    multiplier: 2,
+};
+export async function withRetry(fn, config = DEFAULT_RETRY_CONFIG) {
+    let lastError;
+    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) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class CircuitBreaker {
+    threshold;
+    resetTimeoutMs;
+    failures = 0;
+    openedAt = null;
+    constructor(threshold = 5, resetTimeoutMs = 60_000) {
+        this.threshold = threshold;
+        this.resetTimeoutMs = resetTimeoutMs;
+    }
+    get state() {
+        if (this.openedAt === null)
+            return 'closed';
+        if (Date.now() - this.openedAt >= this.resetTimeoutMs)
+            return 'half-open';
+        return 'open';
+    }
+    get isOpen() {
+        if (this.openedAt === null)
+            return false;
+        if (Date.now() - this.openedAt >= this.resetTimeoutMs) {
+            this.openedAt = null;
+            this.failures = 0;
+            return false;
+        }
+        return true;
+    }
+    async execute(fn) {
+        if (this.isOpen) {
+            throw new Error('Circuit breaker is open — ERP 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() {
+        this.failures = 0;
+        this.openedAt = null;
+    }
+}

package/dist/erp-client/types.d.ts

@@ -0,0 +1,155 @@
+/**
+ * ERP surface types for infor.
+ * Domain types and Infor wire format types for the ACL boundary.
+ */
+export type ErpSystemType = 'infor';
+export interface ErpSurfaceRequest {
+    readonly erp_type: ErpSystemType;
+    readonly operation: string;
+    readonly entity_type: string;
+    readonly query?: Record<string, unknown>;
+    readonly correlation_id: string;
+}
+export interface ErpSurfaceResponse {
+    readonly id: string;
+    readonly status: number;
+    readonly message: string;
+    readonly data: unknown;
+    readonly correlation_id: string;
+    readonly timestamp: string;
+}
+export interface DomainTransferOrder {
+    readonly id: string;
+    readonly from_facility: string;
+    readonly to_facility: string;
+    readonly sku: string;
+    readonly quantity: number;
+    readonly status: string;
+    readonly priority: string;
+}
+export interface DomainPurchaseOrder {
+    readonly id: string;
+    readonly facility_id: string;
+    readonly sku: string;
+    readonly quantity: number;
+    readonly vendor_id: string;
+    readonly status: string;
+}
+export interface DomainInventoryBalance {
+    readonly facility_id: string;
+    readonly sku: string;
+    readonly quantity: number;
+    readonly unit_of_measure: string;
+    readonly last_synced_at: string;
+}
+export interface DomainItemReceipt {
+    readonly transfer_id: string;
+    readonly facility_id: string;
+    readonly sku: string;
+    readonly quantity_received: number;
+    readonly received_at: string;
+}
+export interface InforTransferOrder {
+    readonly subsidiary: {
+        readonly id: string;
+    };
+    readonly location: {
+        readonly id: string;
+    };
+    readonly transferLocation: {
+        readonly id: string;
+    };
+    readonly memo?: string;
+    readonly item: {
+        readonly items: ReadonlyArray<{
+            readonly item: {
+                readonly id: string;
+            };
+            readonly quantity: number;
+            readonly units?: {
+                readonly id: string;
+            };
+        }>;
+    };
+}
+export interface InforPurchaseOrder {
+    readonly entity: {
+        readonly id: string;
+    };
+    readonly subsidiary: {
+        readonly id: string;
+    };
+    readonly location: {
+        readonly id: string;
+    };
+    readonly memo?: string;
+    readonly item: {
+        readonly items: ReadonlyArray<{
+            readonly item: {
+                readonly id: string;
+            };
+            readonly quantity: number;
+            readonly rate?: number;
+        }>;
+    };
+}
+export interface InforInventoryBalance {
+    readonly subsidiary: {
+        readonly id: string;
+        readonly refName: string;
+    };
+    readonly location: {
+        readonly id: string;
+        readonly refName: string;
+    };
+    readonly item: {
+        readonly id: string;
+        readonly refName: string;
+    };
+    readonly quantityOnHand: number;
+    readonly quantityAvailable: number;
+    readonly lastModifiedDate: string;
+}
+export interface InforItemReceipt {
+    readonly createdFrom: {
+        readonly id: string;
+    };
+    readonly subsidiary: {
+        readonly id: string;
+    };
+    readonly item: {
+        readonly items: ReadonlyArray<{
+            readonly item: {
+                readonly id: string;
+            };
+            readonly quantity: number;
+            readonly location: {
+                readonly id: string;
+            };
+        }>;
+    };
+}
+export interface GovernanceConfig {
+    readonly read_only: boolean;
+    readonly audit_enabled: boolean;
+    readonly pii_redaction: boolean;
+    readonly max_tokens_per_request: number;
+}
+export interface SyncQueueEntry {
+    readonly id: string;
+    readonly operation: string;
+    readonly payload: unknown;
+    readonly created_at: string;
+    readonly retry_count: number;
+    readonly last_error: string | null;
+}
+export interface SyncStatus {
+    readonly last_successful_sync: string | null;
+    readonly pending_queue_depth: number;
+    readonly circuit_breaker_state: 'closed' | 'open' | 'half-open';
+    readonly recent_errors: ReadonlyArray<{
+        timestamp: string;
+        operation: string;
+        error: string;
+    }>;
+}

package/dist/erp-client/types.js

@@ -0,0 +1,2 @@
+// Generated by Phase 4 pipeline — do not edit manually
+export {};

package/dist/infra/clients.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Database client interface.
+ * Adapters depend on this abstraction — implementations are injected.
+ */
+export interface DbClient {
+    /** Execute a parameterized query and return rows. */
+    query(sql: string, params: unknown[]): Promise<unknown[]>;
+    /** Execute a parameterized statement (INSERT/UPDATE/DELETE). */
+    execute(sql: string, params: unknown[]): Promise<void>;
+}
+/**
+ * ERP client interface.
+ * Adapters delegate domain operations to the ERP system via this contract.
+ */
+export interface ErpClient {
+    /** Invoke a named ERP operation with a typed payload. */
+    invoke(operation: string, data: unknown): Promise<unknown>;
+}
+/**
+ * Domain-specific error for adapter failures.
+ */
+export declare class AdapterError extends Error {
+    readonly context: string;
+    readonly operation: string;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, context: string, operation: string, cause?: unknown | undefined);
+}

package/dist/infra/clients.js

@@ -0,0 +1,16 @@
+// Generated by Phase 4 pipeline — do not edit manually
+/**
+ * Domain-specific error for adapter failures.
+ */
+export class AdapterError extends Error {
+    context;
+    operation;
+    cause;
+    constructor(message, context, operation, cause) {
+        super(message);
+        this.context = context;
+        this.operation = operation;
+        this.cause = cause;
+        this.name = 'AdapterError';
+    }
+}

package/dist/infra/connection-pool.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Connection Pool Configuration
+ * ERP system: infor
+ * SQL dialect: oracle-sql
+ */
+export interface ConnectionPoolConfig {
+    readonly host: string;
+    readonly port: number;
+    readonly database: string;
+    readonly user: string;
+    readonly password: string;
+    readonly maxConnections: number;
+    readonly idleTimeoutMs: number;
+    readonly ssl: boolean;
+}
+export declare function buildConnectionPoolConfig(): ConnectionPoolConfig;

package/dist/infra/connection-pool.js

@@ -0,0 +1,13 @@
+// Generated by Phase 4 pipeline — do not edit manually
+export function buildConnectionPoolConfig() {
+    return {
+        host: process.env['DB_HOST'] ?? 'localhost',
+        port: Number(process.env['DB_PORT'] ?? 5432),
+        database: process.env['DB_NAME'] ?? 'infor',
+        user: process.env['DB_USER'] ?? '',
+        password: process.env['DB_PASSWORD'] ?? '',
+        maxConnections: Number(process.env['DB_MAX_CONNECTIONS'] ?? 10),
+        idleTimeoutMs: Number(process.env['DB_IDLE_TIMEOUT_MS'] ?? 30000),
+        ssl: process.env['DB_SSL'] !== 'false',
+    };
+}