auditor-lambda 0.3.3 → 0.3.5

package/dist/orchestrator/reviewPackets.js

@@ -0,0 +1,310 @@
+import { createHash } from "node:crypto";
+import { LENS_ORDER } from "./unitBuilder.js";
+const DEFAULT_MAX_TASKS_PER_PACKET = 6;
+const DEFAULT_TARGET_PACKET_LINES = 2500;
+const ESTIMATED_TOKENS_PER_LINE = 4;
+const ESTIMATED_PACKET_PROMPT_TOKENS = 900;
+function priorityRank(priority) {
+    switch (priority) {
+        case "high":
+            return 3;
+        case "medium":
+            return 2;
+        case "low":
+        default:
+            return 1;
+    }
+}
+function normalizePriority(priority) {
+    return priority ?? "low";
+}
+function sortLenses(lenses) {
+    const set = new Set(lenses);
+    return LENS_ORDER.filter((lens) => set.has(lens));
+}
+function lineCountForPath(task, path, lineIndex) {
+    return task.file_line_counts?.[path] ?? lineIndex?.[path] ?? 0;
+}
+function taskLineCount(task, lineIndex) {
+    return task.file_paths.reduce((sum, path) => sum + lineCountForPath(task, path, lineIndex), 0);
+}
+function taskFileSignature(task) {
+    return [...new Set(task.file_paths)].sort((a, b) => a.localeCompare(b)).join("\0");
+}
+function packetGroupingKey(task) {
+    const criticalFlowTag = task.tags?.find((tag) => tag.startsWith("critical_flow:"));
+    const scope = criticalFlowTag ?? task.unit_id;
+    return `${scope}\0${taskFileSignature(task)}`;
+}
+function normalizeGraphPath(path) {
+    return path.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function collectGraphEdges(graphBundle) {
+    if (!graphBundle?.graphs) {
+        return [];
+    }
+    const edges = [];
+    for (const key of ["imports", "calls", "references"]) {
+        const raw = graphBundle.graphs[key];
+        if (!Array.isArray(raw)) {
+            continue;
+        }
+        for (const item of raw) {
+            if (!isRecord(item)) {
+                continue;
+            }
+            if (typeof item.from !== "string" || typeof item.to !== "string") {
+                continue;
+            }
+            edges.push({
+                from: item.from,
+                to: item.to,
+                kind: typeof item.kind === "string" ? item.kind : undefined,
+            });
+        }
+    }
+    return edges;
+}
+function isPacketExpansionEdge(edge) {
+    return edge.kind !== "heuristic-container-edge";
+}
+function sanitizeSegment(value) {
+    const sanitized = value
+        .replace(/[^a-zA-Z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return sanitized.length > 0 ? sanitized : "packet";
+}
+function packetIdFor(tasks, packetIndex) {
+    const unit = sanitizeSegment(tasks[0]?.unit_id ?? "review");
+    const lenses = sortLenses(tasks.map((task) => task.lens)).join("-");
+    const hash = createHash("sha1")
+        .update(tasks.map((task) => task.task_id).join("\0"))
+        .digest("hex")
+        .slice(0, 10);
+    return `${unit}:${lenses}:packet-${packetIndex + 1}-${hash}`;
+}
+function compareTasksForPacket(a, b) {
+    const lensDelta = LENS_ORDER.indexOf(a.lens) - LENS_ORDER.indexOf(b.lens);
+    if (lensDelta !== 0)
+        return lensDelta;
+    return a.task_id.localeCompare(b.task_id);
+}
+function comparePackets(a, b) {
+    const priorityDelta = priorityRank(b.priority) - priorityRank(a.priority);
+    if (priorityDelta !== 0)
+        return priorityDelta;
+    const sizeDelta = b.task_ids.length - a.task_ids.length;
+    if (sizeDelta !== 0)
+        return sizeDelta;
+    return a.packet_id.localeCompare(b.packet_id);
+}
+function chunkPacketTasks(tasks, options) {
+    const chunks = [];
+    let current = [];
+    for (const task of tasks.sort(compareTasksForPacket)) {
+        const isolatedLargeFileTask = task.file_paths.length === 1 &&
+            taskLineCount(task, options.lineIndex) > options.targetPacketLines;
+        if (isolatedLargeFileTask) {
+            if (current.length > 0) {
+                chunks.push(current);
+                current = [];
+            }
+            chunks.push([task]);
+            continue;
+        }
+        const candidate = [...current, task];
+        const uniquePaths = new Set(candidate.flatMap((item) => item.file_paths));
+        const candidateLines = [...uniquePaths].reduce((sum, path) => {
+            const owner = candidate.find((item) => item.file_paths.includes(path));
+            return sum + (owner ? lineCountForPath(owner, path, options.lineIndex) : 0);
+        }, 0);
+        const wouldExceedTaskCount = current.length > 0 && candidate.length > options.maxTasksPerPacket;
+        const wouldExceedLines = current.length > 0 && candidateLines > options.targetPacketLines;
+        if (wouldExceedTaskCount || wouldExceedLines) {
+            chunks.push(current);
+            current = [];
+        }
+        current.push(task);
+    }
+    if (current.length > 0) {
+        chunks.push(current);
+    }
+    return chunks;
+}
+function mergeGraphConnectedGroups(groups, graphBundle) {
+    const groupKeys = [...groups.keys()];
+    const parent = new Map(groupKeys.map((key) => [key, key]));
+    const fileToGroupKeys = new Map();
+    function find(key) {
+        const current = parent.get(key) ?? key;
+        if (current === key)
+            return key;
+        const root = find(current);
+        parent.set(key, root);
+        return root;
+    }
+    function union(a, b) {
+        const rootA = find(a);
+        const rootB = find(b);
+        if (rootA === rootB)
+            return;
+        const [keep, move] = rootA.localeCompare(rootB) <= 0 ? [rootA, rootB] : [rootB, rootA];
+        parent.set(move, keep);
+    }
+    for (const [key, tasks] of groups) {
+        for (const path of new Set(tasks.flatMap((task) => task.file_paths))) {
+            const normalized = normalizeGraphPath(path);
+            const existing = fileToGroupKeys.get(normalized) ?? new Set();
+            existing.add(key);
+            fileToGroupKeys.set(normalized, existing);
+        }
+    }
+    for (const keys of fileToGroupKeys.values()) {
+        const [first, ...rest] = [...keys].sort((a, b) => a.localeCompare(b));
+        if (!first)
+            continue;
+        for (const key of rest) {
+            union(first, key);
+        }
+    }
+    for (const edge of collectGraphEdges(graphBundle)) {
+        if (!isPacketExpansionEdge(edge)) {
+            continue;
+        }
+        const fromGroups = fileToGroupKeys.get(normalizeGraphPath(edge.from));
+        const toGroups = fileToGroupKeys.get(normalizeGraphPath(edge.to));
+        if (!fromGroups || !toGroups) {
+            continue;
+        }
+        for (const fromKey of fromGroups) {
+            for (const toKey of toGroups) {
+                union(fromKey, toKey);
+            }
+        }
+    }
+    const merged = new Map();
+    for (const key of groupKeys) {
+        const root = find(key);
+        const current = merged.get(root) ?? [];
+        current.push(...(groups.get(key) ?? []));
+        merged.set(root, current);
+    }
+    return [...merged.values()];
+}
+function buildPacket(tasks, packetIndex, lineIndex) {
+    const filePaths = [...new Set(tasks.flatMap((task) => task.file_paths))].sort((a, b) => a.localeCompare(b));
+    const fileLineCounts = Object.fromEntries(filePaths.map((path) => {
+        const owner = tasks.find((task) => task.file_paths.includes(path));
+        return [path, owner ? lineCountForPath(owner, path, lineIndex) : 0];
+    }));
+    const totalLines = Object.values(fileLineCounts).reduce((sum, value) => sum + value, 0);
+    const priority = tasks.reduce((highest, task) => priorityRank(task.priority) > priorityRank(highest)
+        ? normalizePriority(task.priority)
+        : highest, "low");
+    const lenses = sortLenses(tasks.map((task) => task.lens));
+    const tags = [
+        ...new Set(tasks.flatMap((task) => task.tags ?? [])),
+    ].sort((a, b) => a.localeCompare(b));
+    return {
+        packet_id: packetIdFor(tasks, packetIndex),
+        task_ids: tasks.map((task) => task.task_id),
+        unit_ids: [...new Set(tasks.map((task) => task.unit_id))].sort((a, b) => a.localeCompare(b)),
+        pass_ids: [...new Set(tasks.map((task) => task.pass_id))].sort((a, b) => a.localeCompare(b)),
+        lenses,
+        file_paths: filePaths,
+        file_line_counts: fileLineCounts,
+        total_lines: totalLines,
+        priority,
+        tags: tags.length > 0 ? tags : undefined,
+        rationale: tasks.length === 1
+            ? tasks[0].rationale
+            : `Review ${filePaths.length} related file(s) across ${lenses.length} lens(es): ${lenses.join(", ")}.`,
+        estimated_tokens: ESTIMATED_PACKET_PROMPT_TOKENS + totalLines * ESTIMATED_TOKENS_PER_LINE,
+    };
+}
+export function buildReviewPackets(tasks, options = {}) {
+    const maxTasksPerPacket = options.maxTasksPerPacket ?? DEFAULT_MAX_TASKS_PER_PACKET;
+    const targetPacketLines = options.targetPacketLines ?? DEFAULT_TARGET_PACKET_LINES;
+    const groups = new Map();
+    for (const task of tasks) {
+        const key = packetGroupingKey(task);
+        const group = groups.get(key) ?? [];
+        group.push(task);
+        groups.set(key, group);
+    }
+    const packets = [];
+    let packetIndex = 0;
+    const groupedTasks = mergeGraphConnectedGroups(groups, options.graphBundle).sort((a, b) => {
+        const aPriority = Math.max(...a.map((task) => priorityRank(task.priority)));
+        const bPriority = Math.max(...b.map((task) => priorityRank(task.priority)));
+        if (aPriority !== bPriority)
+            return bPriority - aPriority;
+        return (a[0]?.task_id ?? "").localeCompare(b[0]?.task_id ?? "");
+    });
+    for (const group of groupedTasks) {
+        for (const chunk of chunkPacketTasks(group, {
+            lineIndex: options.lineIndex,
+            maxTasksPerPacket,
+            targetPacketLines,
+        })) {
+            packets.push(buildPacket(chunk, packetIndex, options.lineIndex));
+            packetIndex += 1;
+        }
+    }
+    return packets.sort(comparePackets);
+}
+export function orderTasksForPacketReview(tasks, options = {}) {
+    const taskById = new Map(tasks.map((task) => [task.task_id, task]));
+    return buildReviewPackets(tasks, options).flatMap((packet) => packet.task_ids
+        .map((taskId) => taskById.get(taskId))
+        .filter((task) => task !== undefined));
+}
+export function buildAuditPlanMetrics(tasks, options = {}) {
+    const packets = buildReviewPackets(tasks, options);
+    const taskLineCounts = tasks.map((task) => taskLineCount(task, options.lineIndex));
+    const totalTaskLines = taskLineCounts.reduce((sum, value) => sum + value, 0);
+    const totalPacketLines = packets.reduce((sum, packet) => sum + packet.total_lines, 0);
+    const largestTaskIndex = taskLineCounts.reduce((largest, value, index) => (value > taskLineCounts[largest] ? index : largest), 0);
+    const largestPacket = packets.reduce((largest, packet) => !largest || packet.total_lines > largest.total_lines ? packet : largest, undefined);
+    const taskFileReferences = tasks.reduce((sum, task) => sum + task.file_paths.length, 0);
+    const uniqueFiles = new Set(tasks.flatMap((task) => task.file_paths));
+    const lensTaskCounts = {};
+    const priorityTaskCounts = {
+        high: 0,
+        medium: 0,
+        low: 0,
+    };
+    for (const task of tasks) {
+        lensTaskCounts[task.lens] = (lensTaskCounts[task.lens] ?? 0) + 1;
+        priorityTaskCounts[normalizePriority(task.priority)] += 1;
+    }
+    return {
+        generated_at: (options.generatedAt ?? new Date()).toISOString(),
+        task_count: tasks.length,
+        packet_count: packets.length,
+        estimated_agent_reduction: Math.max(0, tasks.length - packets.length),
+        estimated_agent_reduction_ratio: tasks.length === 0 ? 0 : Math.max(0, tasks.length - packets.length) / tasks.length,
+        unique_file_count: uniqueFiles.size,
+        task_file_reference_count: taskFileReferences,
+        repeated_file_reference_count: Math.max(0, taskFileReferences - uniqueFiles.size),
+        total_task_lines: totalTaskLines,
+        total_packet_lines: totalPacketLines,
+        repeated_line_reference_count: Math.max(0, totalTaskLines - totalPacketLines),
+        min_task_lines: taskLineCounts.length > 0 ? Math.min(...taskLineCounts) : 0,
+        max_task_lines: taskLineCounts.length > 0 ? Math.max(...taskLineCounts) : 0,
+        average_task_lines: taskLineCounts.length > 0 ? totalTaskLines / taskLineCounts.length : 0,
+        largest_task_id: tasks[largestTaskIndex]?.task_id,
+        largest_packet_id: largestPacket?.packet_id,
+        lens_task_counts: lensTaskCounts,
+        priority_task_counts: priorityTaskCounts,
+        packet_size: {
+            single_task_packets: packets.filter((packet) => packet.task_ids.length === 1).length,
+            multi_task_packets: packets.filter((packet) => packet.task_ids.length > 1).length,
+            max_tasks_per_packet: packets.length > 0 ? Math.max(...packets.map((packet) => packet.task_ids.length)) : 0,
+            max_files_per_packet: packets.length > 0 ? Math.max(...packets.map((packet) => packet.file_paths.length)) : 0,
+        },
+    };
+}

package/dist/orchestrator/selectiveDeepening.d.ts

@@ -0,0 +1,14 @@
+import type { AuditResult, AuditTask } from "../types.js";
+import type { RuntimeValidationReport, RuntimeValidationTaskManifest } from "../types/runtimeValidation.js";
+export interface BuildSelectiveDeepeningTaskOptions {
+    existingTasks?: AuditTask[];
+    results: AuditResult[];
+    lineIndex?: Record<string, number>;
+    runtimeValidationTasks?: RuntimeValidationTaskManifest;
+    runtimeValidationReport?: RuntimeValidationReport;
+    maxTasks?: number;
+}
+export declare function buildSelectiveDeepeningTasks(options: BuildSelectiveDeepeningTaskOptions): AuditTask[];
+export declare const selectiveDeepeningTestUtils: {
+    DEEPENING_TAG: string;
+};