@kbediako/codex-orchestrator 0.1.0

package/dist/packages/shared/design-artifacts/writer.js

@@ -0,0 +1,221 @@
+import { mkdir, rename, writeFile } from 'node:fs/promises';
+import { dirname, join, relative as relativePath } from 'node:path';
+import { persistDesignManifest } from '../manifest/writer.js';
+export async function writeDesignSummary(options) {
+    const now = options.now ?? new Date();
+    const context = options.context;
+    const artifacts = options.artifacts ?? [];
+    const summary = options.summary ?? deriveSummary(artifacts, now);
+    const toolkitArtifacts = options.toolkitArtifacts ?? [];
+    const approvals = options.approvals ?? [];
+    const toolkitSummary = options.toolkitSummary ?? (toolkitArtifacts.length > 0 ? deriveToolkitSummary(toolkitArtifacts, approvals, now) : undefined);
+    const manifestUpdate = {
+        artifacts,
+        summary,
+        configSnapshot: options.configSnapshot ?? null,
+        ...(toolkitArtifacts.length > 0 ? { toolkitArtifacts } : {}),
+        ...(toolkitSummary ? { toolkitSummary } : {}),
+        ...(options.designPlan !== undefined ? { designPlan: options.designPlan } : {}),
+        ...(options.designGuardrail !== undefined ? { designGuardrail: options.designGuardrail } : {}),
+        ...(options.designHistory !== undefined ? { designHistory: options.designHistory } : {}),
+        ...(options.designStyleProfile !== undefined ? { designStyleProfile: options.designStyleProfile } : {}),
+        ...(options.designMetrics !== undefined ? { designMetrics: options.designMetrics } : {})
+    };
+    const manifestOptions = {
+        retentionDays: options.retention.days,
+        retentionPolicy: options.retention.policy,
+        now,
+        ...options.manifestOptions
+    };
+    const manifest = await persistDesignManifest(context.manifestPath, manifestUpdate, manifestOptions);
+    const payload = buildSummaryPayload(options, summary, toolkitSummary, manifest, now);
+    const summaryPath = await writeSummaryFile(options, payload);
+    return {
+        manifest: context.manifestPath,
+        summaryPath,
+        summary: payload
+    };
+}
+function buildSummaryPayload(options, summary, toolkitSummary, manifest, now) {
+    const context = options.context;
+    const repoRoot = options.context.repoRoot ?? process.cwd();
+    const manifestRelative = relativePath(repoRoot, context.manifestPath);
+    const approvals = (options.approvals ?? [])
+        .map((approval) => ({
+        id: approval.id,
+        actor: approval.actor,
+        reason: approval.reason,
+        timestamp: approval.timestamp
+    }))
+        .filter((approval) => approval.id && approval.actor && approval.timestamp);
+    const stages = options.stages.map((stage) => {
+        const artifacts = (stage.artifacts ?? []).map((artifact) => ({
+            relative_path: artifact.relative_path,
+            stage: artifact.stage ?? stage.id,
+            status: artifact.status ?? stage.status,
+            type: artifact.type,
+            description: artifact.description
+        }));
+        return {
+            id: stage.id,
+            title: stage.title ?? null,
+            status: stage.status,
+            notes: stage.notes ?? [],
+            metrics: stage.metrics ?? {},
+            artifacts
+        };
+    });
+    const summaryArtifacts = (options.artifacts ?? []).map((artifact) => ({
+        stage: artifact.stage,
+        status: artifact.status,
+        relative_path: artifact.relative_path,
+        type: artifact.type,
+        description: artifact.description
+    }));
+    const toolkitArtifacts = (options.toolkitArtifacts ?? []).map((artifact) => ({
+        id: artifact.id,
+        stage: artifact.stage,
+        status: artifact.status,
+        relative_path: artifact.relative_path,
+        description: artifact.description ?? null,
+        metrics: artifact.metrics ?? {},
+        retention: artifact.retention ?? null
+    }));
+    const designMetrics = manifest.design_metrics ?? options.designMetrics ?? null;
+    const combinedMetrics = {
+        ...(options.metrics ?? {}),
+        ...(designMetrics ?? {})
+    };
+    return {
+        task_id: context.taskId,
+        run_id: context.runId,
+        manifest: manifestRelative,
+        generated_at: now.toISOString(),
+        retention: {
+            days: options.retention.days,
+            auto_purge: options.retention.autoPurge,
+            policy: options.retention.policy ?? 'design.config.retention'
+        },
+        privacy: {
+            allow_third_party: options.privacy.allowThirdParty,
+            require_approval: options.privacy.requireApproval,
+            mask_selectors: options.privacy.maskSelectors,
+            approver: options.privacy.approver ?? null
+        },
+        approvals,
+        stages,
+        artifacts: summaryArtifacts,
+        summary,
+        design_toolkit_artifacts: toolkitArtifacts,
+        design_toolkit_summary: toolkitSummary ?? null,
+        design_plan: manifest.design_plan ?? options.designPlan ?? null,
+        design_guardrail: manifest.design_guardrail ?? options.designGuardrail ?? null,
+        design_history: manifest.design_history ?? options.designHistory ?? null,
+        design_style_profile: manifest.design_style_profile ?? options.designStyleProfile ?? null,
+        design_metrics: designMetrics,
+        metrics: combinedMetrics,
+        config_snapshot: options.configSnapshot ?? null
+    };
+}
+async function writeSummaryFile(options, payload) {
+    const outRoot = options.outDir ?? join(process.cwd(), 'out');
+    const safeTaskId = sanitizeTaskId(options.context.taskId);
+    const safeRunId = sanitizeRunId(options.context.runId);
+    const summaryPath = join(outRoot, safeTaskId, 'design', 'runs', `${safeRunId}.json`);
+    await writeJsonAtomic(summaryPath, payload);
+    return summaryPath;
+}
+function deriveSummary(artifacts, now) {
+    const stageMap = new Map();
+    for (const artifact of artifacts) {
+        const entry = stageMap.get(artifact.stage) ?? {
+            succeeded: 0,
+            failed: 0,
+            skipped: 0,
+            artifacts: 0
+        };
+        entry.artifacts += 1;
+        if (artifact.status === 'succeeded') {
+            entry.succeeded += 1;
+        }
+        else if (artifact.status === 'failed') {
+            entry.failed += 1;
+        }
+        else {
+            entry.skipped += 1;
+        }
+        stageMap.set(artifact.stage, entry);
+    }
+    const stages = Array.from(stageMap.entries()).map(([stage, stats]) => ({
+        stage,
+        succeeded: stats.succeeded,
+        failed: stats.failed,
+        skipped: stats.skipped,
+        artifacts: stats.artifacts
+    }));
+    return {
+        total_artifacts: artifacts.length,
+        generated_at: now.toISOString(),
+        stages
+    };
+}
+function deriveToolkitSummary(artifacts, approvals, now) {
+    const stageMap = new Map();
+    const totals = {};
+    for (const artifact of artifacts) {
+        const entry = stageMap.get(artifact.stage) ?? { count: 0, metrics: {} };
+        entry.count += 1;
+        if (artifact.metrics) {
+            accumulateToolkitMetrics(entry.metrics, artifact.metrics);
+            accumulateNumericTotals(totals, artifact.metrics);
+        }
+        stageMap.set(artifact.stage, entry);
+    }
+    const stages = Array.from(stageMap.entries()).map(([stage, data]) => ({
+        stage,
+        artifacts: data.count,
+        metrics: data.metrics
+    }));
+    const approvalIds = approvals.map((approval) => approval.id).filter(Boolean);
+    return {
+        generated_at: now.toISOString(),
+        stages,
+        totals: Object.keys(totals).length > 0 ? totals : undefined,
+        approvals: approvalIds.length > 0 ? approvalIds : undefined
+    };
+}
+function accumulateToolkitMetrics(target, incoming) {
+    for (const [key, value] of Object.entries(incoming)) {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            const current = target[key];
+            if (typeof current === 'number') {
+                target[key] = current + value;
+            }
+            else {
+                target[key] = value;
+            }
+        }
+        else if (typeof value === 'string') {
+            target[key] = value;
+        }
+    }
+}
+function accumulateNumericTotals(target, incoming) {
+    for (const [key, value] of Object.entries(incoming)) {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            target[key] = (target[key] ?? 0) + value;
+        }
+    }
+}
+function sanitizeTaskId(value) {
+    return value.replace(/[^a-zA-Z0-9_-]/g, '').toLowerCase();
+}
+function sanitizeRunId(value) {
+    return value.replace(/[:]/g, '-');
+}
+async function writeJsonAtomic(targetPath, payload) {
+    const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+    await mkdir(dirname(targetPath), { recursive: true });
+    await writeFile(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    await rename(tmpPath, targetPath);
+}

package/dist/packages/shared/events/serializer.js

@@ -0,0 +1,84 @@
+function serializeBegin(event) {
+    return {
+        type: event.type,
+        timestamp: event.timestamp,
+        payload: {
+            attempt: event.attempt,
+            correlationId: event.correlationId,
+            command: event.payload.command,
+            args: event.payload.args,
+            cwd: event.payload.cwd ?? null,
+            sessionId: event.payload.sessionId,
+            sandboxState: event.payload.sandboxState,
+            persisted: event.payload.persisted
+        }
+    };
+}
+function serializeChunk(event) {
+    return {
+        type: event.type,
+        timestamp: event.timestamp,
+        payload: {
+            attempt: event.attempt,
+            correlationId: event.correlationId,
+            stream: event.payload.stream,
+            sequence: event.payload.sequence,
+            bytes: event.payload.bytes,
+            data: event.payload.data
+        }
+    };
+}
+function serializeEnd(event) {
+    return {
+        type: event.type,
+        timestamp: event.timestamp,
+        payload: {
+            attempt: event.attempt,
+            correlationId: event.correlationId,
+            exitCode: event.payload.exitCode,
+            signal: event.payload.signal,
+            durationMs: event.payload.durationMs,
+            stdout: event.payload.stdout,
+            stderr: event.payload.stderr,
+            sandboxState: event.payload.sandboxState,
+            sessionId: event.payload.sessionId,
+            status: event.payload.status
+        }
+    };
+}
+function serializeRetry(event) {
+    return {
+        type: event.type,
+        timestamp: event.timestamp,
+        payload: {
+            attempt: event.attempt,
+            correlationId: event.correlationId,
+            delayMs: event.payload.delayMs,
+            sandboxState: event.payload.sandboxState,
+            errorMessage: event.payload.errorMessage
+        }
+    };
+}
+export function serializeExecEvent(event) {
+    switch (event.type) {
+        case 'exec:begin':
+            return serializeBegin(event);
+        case 'exec:chunk':
+            return serializeChunk(event);
+        case 'exec:end':
+            return serializeEnd(event);
+        case 'exec:retry':
+            return serializeRetry(event);
+        default: {
+            const exhaustive = event;
+            return exhaustive;
+        }
+    }
+}
+export function serializeRunSummaryEvent(payload, timestamp = new Date().toISOString()) {
+    return {
+        type: 'run:summary',
+        timestamp,
+        payload
+    };
+}

package/dist/packages/shared/events/types.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/shared/manifest/artifactUtils.js

@@ -0,0 +1,36 @@
+export function sanitizeRelativeArtifactPath(value) {
+    const normalized = value.replace(/\\+/g, '/').split('/');
+    const segments = [];
+    for (const segmentRaw of normalized) {
+        const segment = segmentRaw.trim();
+        if (!segment || segment === '.') {
+            continue;
+        }
+        if (segment === '..' || segment.includes('..')) {
+            throw new Error(`relative_path contains invalid segment '${segment}'`);
+        }
+        segments.push(segment);
+    }
+    if (segments.length === 0) {
+        throw new Error('relative_path must include at least one segment');
+    }
+    return segments.join('/');
+}
+export function isIsoDate(value) {
+    const trimmed = value.trim();
+    const isoPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+    if (!isoPattern.test(trimmed)) {
+        return false;
+    }
+    const date = new Date(trimmed);
+    return !Number.isNaN(date.getTime());
+}
+export function coerceNonNegativeInteger(value) {
+    if (typeof value === 'number' || typeof value === 'string') {
+        const converted = typeof value === 'number' ? value : Number(value);
+        if (Number.isFinite(converted) && converted >= 0) {
+            return Math.floor(converted);
+        }
+    }
+    return null;
+}