@wowok/agent-mcp 2.4.3 → 2.5.1

package/dist/project/substep-trace.js

@@ -0,0 +1,332 @@
+function buildEdgesFromInputRefs(substeps) {
+    const edges = [];
+    for (const substep of substeps) {
+        for (const ref of substep.dependencies.input_refs) {
+            const field_path = substep.dependencies.output_refs
+                .find((r) => r.substep_id === ref)?.field_path ?? "input_ref";
+            edges.push({ source: ref, target: substep.step_id, field_path });
+        }
+    }
+    return edges;
+}
+function groupByParentStep(substeps) {
+    const groups = new Map();
+    for (const s of substeps) {
+        if (!groups.has(s.parent_step))
+            groups.set(s.parent_step, []);
+        groups.get(s.parent_step).push(s);
+    }
+    return groups;
+}
+function buildStepDetails(substeps) {
+    const groups = groupByParentStep(substeps);
+    const details = [];
+    for (const [parent_step, group] of groups.entries()) {
+        let successful = 0, failed = 0, pending = 0, skipped = 0;
+        const substep_ids = [];
+        for (const s of group) {
+            substep_ids.push(s.step_id);
+            switch (s.status) {
+                case "SUCCESS":
+                    successful++;
+                    break;
+                case "FAILED":
+                    failed++;
+                    break;
+                case "PENDING":
+                    pending++;
+                    break;
+                case "SKIPPED":
+                    skipped++;
+                    break;
+            }
+        }
+        details.push({
+            parent_step,
+            total_substeps: group.length,
+            successful,
+            failed,
+            pending,
+            skipped,
+            substep_ids,
+        });
+    }
+    details.sort((a, b) => {
+        const na = parseInt(a.parent_step.replace(/^T/, ""), 10) || 0;
+        const nb = parseInt(b.parent_step.replace(/^T/, ""), 10) || 0;
+        return na - nb;
+    });
+    return details;
+}
+export function detectDanglingInputs(substeps, edges) {
+    if (!substeps || substeps.length === 0)
+        return [];
+    const substep_ids = new Set(substeps.map((s) => s.step_id));
+    const dangling = [];
+    for (const substep of substeps) {
+        for (const ref of substep.dependencies.input_refs) {
+            if (!substep_ids.has(ref)) {
+                const field_path = substep.dependencies.output_refs.find((r) => r.substep_id === ref)?.field_path ??
+                    edges?.find((e) => e.source === ref && e.target === substep.step_id)?.field_path ??
+                    "input_ref";
+                dangling.push({
+                    substep_id: substep.step_id,
+                    missing_ref: ref,
+                    field_path,
+                });
+            }
+        }
+    }
+    return dangling;
+}
+export function detectCircularRefs(substeps, edges) {
+    if (!substeps || substeps.length === 0)
+        return [];
+    if (!edges || edges.length === 0)
+        return [];
+    const cycles = [];
+    const visited = new Set();
+    const recursion_stack = new Set();
+    const path = [];
+    const adjacency = new Map();
+    for (const s of substeps)
+        adjacency.set(s.step_id, []);
+    for (const edge of edges) {
+        if (!adjacency.has(edge.source))
+            adjacency.set(edge.source, []);
+        adjacency.get(edge.source).push(edge.target);
+    }
+    const dfs = (node) => {
+        if (recursion_stack.has(node)) {
+            const cycle_start = path.indexOf(node);
+            if (cycle_start >= 0) {
+                cycles.push({ cycle: [...path.slice(cycle_start), node] });
+            }
+            return;
+        }
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        recursion_stack.add(node);
+        path.push(node);
+        const neighbors = adjacency.get(node) ?? [];
+        for (const next of neighbors) {
+            dfs(next);
+        }
+        path.pop();
+        recursion_stack.delete(node);
+    };
+    for (const s of substeps) {
+        if (!visited.has(s.step_id)) {
+            dfs(s.step_id);
+        }
+    }
+    return cycles;
+}
+export function detectMissingOutputs(substeps) {
+    if (!substeps || substeps.length === 0)
+        return [];
+    const missing = [];
+    for (const substep of substeps) {
+        for (const dep of substep.dependencies.output_refs) {
+            const field_path = dep.field_path;
+            const has_field = !!substep.output &&
+                typeof substep.output === "object" &&
+                field_path in substep.output;
+            if (!has_field) {
+                missing.push({
+                    substep_id: substep.step_id,
+                    expected_field: field_path,
+                    dependent_substeps: [dep.substep_id],
+                });
+            }
+        }
+    }
+    return missing;
+}
+export function detectCrossStepBreaks(substeps, edges) {
+    if (!substeps || substeps.length === 0 || !edges || edges.length === 0)
+        return [];
+    const breaks = [];
+    const id_to_step = new Map();
+    for (const s of substeps)
+        id_to_step.set(s.step_id, s.parent_step);
+    const step_groups = groupByParentStep(substeps);
+    const failed_steps = new Set();
+    for (const [parent_step, group] of step_groups.entries()) {
+        if (group.some((s) => s.status === "FAILED")) {
+            failed_steps.add(parent_step);
+        }
+    }
+    const seen = new Set();
+    for (const edge of edges) {
+        const source_step = id_to_step.get(edge.source);
+        const target_step = id_to_step.get(edge.target);
+        if (!source_step || !target_step)
+            continue;
+        if (source_step === target_step)
+            continue;
+        if (!failed_steps.has(source_step))
+            continue;
+        const key = `${source_step}|${target_step}|${edge.field_path}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        breaks.push({
+            source_step,
+            target_step,
+            missing_field: edge.field_path,
+        });
+    }
+    return breaks;
+}
+function topologicalSort(substeps, edges) {
+    if (!substeps || substeps.length === 0)
+        return [];
+    const in_degree = new Map();
+    const adjacency = new Map();
+    for (const s of substeps) {
+        in_degree.set(s.step_id, 0);
+        adjacency.set(s.step_id, []);
+    }
+    for (const edge of edges) {
+        if (!adjacency.has(edge.source))
+            adjacency.set(edge.source, []);
+        if (!in_degree.has(edge.target))
+            in_degree.set(edge.target, 0);
+        adjacency.get(edge.source).push(edge.target);
+        in_degree.set(edge.target, (in_degree.get(edge.target) ?? 0) + 1);
+    }
+    const queue = [];
+    for (const s of substeps) {
+        if ((in_degree.get(s.step_id) ?? 0) === 0)
+            queue.push(s.step_id);
+    }
+    const order = [];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        order.push(node);
+        const neighbors = adjacency.get(node) ?? [];
+        for (const next of neighbors) {
+            const d = (in_degree.get(next) ?? 0) - 1;
+            in_degree.set(next, d);
+            if (d === 0)
+                queue.push(next);
+        }
+    }
+    if (order.length !== substeps.length)
+        return [];
+    return order;
+}
+function buildD10Check(dangling, circular, missing, breaks) {
+    const notes = [];
+    if (dangling.length > 0) {
+        notes.push(`${dangling.length} dangling input(s) detected`);
+    }
+    if (circular.length > 0) {
+        notes.push(`${circular.length} circular reference(s) detected`);
+    }
+    if (missing.length > 0) {
+        notes.push(`${missing.length} missing output(s) detected`);
+    }
+    if (breaks.length > 0) {
+        notes.push(`${breaks.length} cross-step break(s) detected`);
+    }
+    let status;
+    if (dangling.length === 0 && circular.length === 0 && breaks.length === 0 && missing.length === 0) {
+        status = "PASS";
+    }
+    else if (circular.length > 0 || dangling.length > 0 || breaks.length > 0) {
+        status = "FAIL";
+    }
+    else {
+        status = "WARN";
+    }
+    return {
+        check_id: "D-10",
+        description: "Substep coherence (dangling inputs, circular refs, missing outputs, cross-step breaks)",
+        status,
+        notes: notes.length > 0 ? notes : ["All substep coherence checks passed"],
+    };
+}
+export function traceSubsteps(input) {
+    const substeps = input.substeps ?? [];
+    const edges = input.edges ?? buildEdgesFromInputRefs(substeps);
+    const dangling_inputs = detectDanglingInputs(substeps, edges);
+    const circular_refs = detectCircularRefs(substeps, edges);
+    const missing_outputs = detectMissingOutputs(substeps);
+    const cross_step_breaks = detectCrossStepBreaks(substeps, edges);
+    const coherent = dangling_inputs.length === 0 &&
+        circular_refs.length === 0 &&
+        missing_outputs.length === 0 &&
+        cross_step_breaks.length === 0;
+    const topological_order = topologicalSort(substeps, edges);
+    const step_details = buildStepDetails(substeps);
+    const d10_check = buildD10Check(dangling_inputs, circular_refs, missing_outputs, cross_step_breaks);
+    return {
+        namespace: { prefix: input.project_prefix, version: input.version },
+        network: input.network,
+        coherent,
+        dangling_inputs,
+        circular_refs,
+        missing_outputs,
+        cross_step_breaks,
+        step_details,
+        topological_order,
+        d10_check,
+    };
+}
+export class SubstepTracer {
+    records = new Map();
+    namespace;
+    network;
+    constructor(prefix, version, network) {
+        this.namespace = { prefix, version };
+        this.network = network;
+    }
+    record(rec) {
+        if (!rec || !rec.step_id)
+            return;
+        this.records.set(rec.step_id, rec);
+    }
+    getTrace() {
+        return Array.from(this.records.values()).filter((s) => s.network === this.network);
+    }
+    updateStatus(step_id, status, output, failure_reason) {
+        const rec = this.records.get(step_id);
+        if (!rec)
+            return;
+        rec.status = status;
+        if (output)
+            rec.output = { ...(rec.output ?? {}), ...output };
+        if (failure_reason)
+            rec.failure_reason = failure_reason;
+        rec.timestamp = Date.now();
+    }
+    getDAG() {
+        const substeps = this.getTrace();
+        const edges = buildEdgesFromInputRefs(substeps);
+        return {
+            namespace: this.namespace,
+            network: this.network,
+            substeps,
+            edges,
+            topological_order: topologicalSort(substeps, edges),
+        };
+    }
+    checkCoherence() {
+        return traceSubsteps({
+            project_prefix: this.namespace.prefix,
+            version: this.namespace.version,
+            network: this.network,
+            substeps: this.getTrace(),
+        });
+    }
+    toJSON() {
+        return {
+            namespace: this.namespace,
+            network: this.network,
+            substeps: this.getTrace(),
+        };
+    }
+}