auditor-lambda 0.1.0

package/dist/orchestrator/planning.js

@@ -0,0 +1,62 @@
+import { applyUnitCoverage, createCoverageMatrix, markExcludedPath, } from "../coverage.js";
+import { isAuditExcludedStatus } from "../extractors/disposition.js";
+function analyzerCategoryToLenses(category) {
+    const normalized = category.toLowerCase();
+    if (normalized.includes("security") || normalized.includes("secret")) {
+        return ["security", "correctness"];
+    }
+    if (normalized.includes("dependency") || normalized.includes("vuln")) {
+        return ["security", "config_deployment"];
+    }
+    if (normalized.includes("tests") || normalized.includes("coverage")) {
+        return ["tests"];
+    }
+    if (normalized.includes("data")) {
+        return ["data_integrity", "correctness"];
+    }
+    if (normalized.includes("reliability") ||
+        normalized.includes("concurrency")) {
+        return ["reliability", "correctness"];
+    }
+    if (normalized.includes("maintainability") ||
+        normalized.includes("lint") ||
+        normalized.includes("style")) {
+        return ["maintainability"];
+    }
+    return ["correctness"];
+}
+function applyAnalyzerCoverage(coverage, externalAnalyzerResults) {
+    if (!externalAnalyzerResults) {
+        return;
+    }
+    for (const result of externalAnalyzerResults.results) {
+        const record = coverage.files.find((file) => file.path === result.path);
+        if (!record || record.audit_status === "excluded") {
+            continue;
+        }
+        const extraLenses = analyzerCategoryToLenses(result.category);
+        record.required_lenses = [
+            ...new Set([...record.required_lenses, ...extraLenses]),
+        ];
+        if (record.classification_status === "unclassified") {
+            record.classification_status = "classified";
+        }
+    }
+}
+export function initializeCoverageFromPlan(repoManifest, unitManifest, disposition, externalAnalyzerResults) {
+    const coverage = createCoverageMatrix(repoManifest.files.map((file) => file.path));
+    const dispositionMap = new Map(disposition.files.map((item) => [item.path, item.status]));
+    for (const file of repoManifest.files) {
+        const status = dispositionMap.get(file.path);
+        if (status && isAuditExcludedStatus(status)) {
+            markExcludedPath(coverage, file.path, status);
+        }
+    }
+    for (const unit of unitManifest.units) {
+        for (const path of unit.files) {
+            applyUnitCoverage(coverage, path, unit.unit_id, unit.required_lenses);
+        }
+    }
+    applyAnalyzerCoverage(coverage, externalAnalyzerResults);
+    return coverage;
+}

package/dist/orchestrator/requeue.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalAnalyzerResults } from "../types/externalAnalyzer.js";
+import type { AuditTask, CoverageMatrix } from "../types.js";
+export declare function buildRequeueTasks(matrix: CoverageMatrix, externalAnalyzerResults?: ExternalAnalyzerResults): AuditTask[];

package/dist/orchestrator/requeue.js

@@ -0,0 +1,25 @@
+import { buildRequeueTargets } from "../coverage.js";
+function taskPriority(hasExternalSignal) {
+    return hasExternalSignal ? "high" : "medium";
+}
+export function buildRequeueTasks(matrix, externalAnalyzerResults) {
+    const targets = buildRequeueTargets(matrix);
+    const tasks = [];
+    const externalPaths = new Set((externalAnalyzerResults?.results ?? []).map((item) => item.path));
+    for (const target of targets) {
+        for (const lens of target.missing_lenses) {
+            const hasExternalSignal = externalPaths.has(target.path);
+            tasks.push({
+                task_id: `requeue:${lens}:${target.path}`,
+                unit_id: `requeue:${target.path}`,
+                pass_id: `requeue:${lens}`,
+                lens,
+                file_paths: [target.path],
+                rationale: `Requeue ${target.path} because the ${lens} lens is still missing.${hasExternalSignal ? " External analyzer signals make this follow-up higher priority." : ""}`,
+                priority: taskPriority(hasExternalSignal),
+                tags: hasExternalSignal ? ["external_analyzer_signal"] : [],
+            });
+        }
+    }
+    return tasks;
+}

package/dist/orchestrator/requeueCommand.d.ts

@@ -0,0 +1,10 @@
+import type { ExternalAnalyzerResults } from "../types/externalAnalyzer.js";
+import type { CoverageMatrix } from "../types.js";
+import type { FlowCoverageManifest } from "../types/flowCoverage.js";
+import type { CriticalFlowManifest } from "../types/flows.js";
+export declare function buildRequeuePayload(matrix: CoverageMatrix, criticalFlows?: CriticalFlowManifest, flowCoverage?: FlowCoverageManifest, externalAnalyzerResults?: ExternalAnalyzerResults): {
+    task_count: number;
+    file_task_count: number;
+    flow_task_count: number;
+    tasks: import("../types.js").AuditTask[];
+};

package/dist/orchestrator/requeueCommand.js

@@ -0,0 +1,27 @@
+import { buildRequeueTasks } from "./requeue.js";
+import { buildFlowRequeueTasks } from "./flowRequeue.js";
+function dedupeTasks(tasks) {
+    const seen = new Set();
+    const deduped = [];
+    for (const task of tasks) {
+        if (seen.has(task.task_id)) {
+            continue;
+        }
+        seen.add(task.task_id);
+        deduped.push(task);
+    }
+    return deduped;
+}
+export function buildRequeuePayload(matrix, criticalFlows, flowCoverage, externalAnalyzerResults) {
+    const fileTasks = dedupeTasks(buildRequeueTasks(matrix, externalAnalyzerResults));
+    const flowTasks = criticalFlows && flowCoverage
+        ? dedupeTasks(buildFlowRequeueTasks(criticalFlows, flowCoverage, externalAnalyzerResults))
+        : [];
+    const tasks = dedupeTasks([...fileTasks, ...flowTasks]);
+    return {
+        task_count: tasks.length,
+        file_task_count: fileTasks.length,
+        flow_task_count: flowTasks.length,
+        tasks,
+    };
+}

package/dist/orchestrator/resultIngestion.d.ts

@@ -0,0 +1,2 @@
+import type { AuditResult, CoverageMatrix } from "../types.js";
+export declare function ingestAuditResults(coverageMatrix: CoverageMatrix, results: AuditResult[]): CoverageMatrix;

package/dist/orchestrator/resultIngestion.js

@@ -0,0 +1,13 @@
+import { applyReviewedRanges } from "../coverage.js";
+export function ingestAuditResults(coverageMatrix, results) {
+    const reviewedRanges = results.flatMap((result) => result.reviewed_ranges.map((range) => ({
+        path: range.path,
+        start: range.start,
+        end: range.end,
+        pass_id: result.pass_id,
+        lens: result.lens,
+        agent_role: result.agent_role,
+    })));
+    applyReviewedRanges(coverageMatrix, reviewedRanges);
+    return coverageMatrix;
+}

package/dist/orchestrator/runtimeValidation.d.ts

@@ -0,0 +1,7 @@
+import type { UnitManifest } from "../types.js";
+import type { FlowCoverageManifest } from "../types/flowCoverage.js";
+import type { CriticalFlowManifest } from "../types/flows.js";
+import type { RuntimeValidationReport, RuntimeValidationTaskManifest } from "../types/runtimeValidation.js";
+export declare function buildRuntimeValidationTasks(unitManifest: UnitManifest, criticalFlows?: CriticalFlowManifest, flowCoverage?: FlowCoverageManifest): RuntimeValidationTaskManifest;
+export declare function buildPlaceholderRuntimeValidationReport(tasks: RuntimeValidationTaskManifest): RuntimeValidationReport;
+export declare function mergeRuntimeValidationReport(tasks: RuntimeValidationTaskManifest, existing?: RuntimeValidationReport): RuntimeValidationReport;

package/dist/orchestrator/runtimeValidation.js

@@ -0,0 +1,103 @@
+function checksForFlow(requiredLenses) {
+    const checks = [];
+    if (requiredLenses.includes("security")) {
+        checks.push("Exercise malformed or unauthorized inputs against the flow.");
+    }
+    if (requiredLenses.includes("reliability")) {
+        checks.push("Exercise retries, repeated submissions, or partial failure behavior.");
+    }
+    if (requiredLenses.includes("correctness")) {
+        checks.push("Exercise representative success and edge-case paths end to end.");
+    }
+    if (requiredLenses.includes("data_integrity")) {
+        checks.push("Verify state transitions and persistence invariants after execution.");
+    }
+    return checks;
+}
+export function buildRuntimeValidationTasks(unitManifest, criticalFlows, flowCoverage) {
+    const tasks = [];
+    const seen = new Set();
+    const highRiskUnits = unitManifest.units.filter((unit) => (unit.risk_score ?? 0) >= 5 ||
+        unit.required_lenses.includes("security") ||
+        unit.required_lenses.includes("data_integrity"));
+    for (const unit of highRiskUnits) {
+        const id = `runtime:unit:${unit.unit_id}`;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        tasks.push({
+            id,
+            kind: "unit-risk-check",
+            target_paths: unit.files,
+            reason: `Unit ${unit.unit_id} is high risk or touches sensitive concerns.`,
+            priority: (unit.risk_score ?? 0) >= 7 ? "high" : "medium",
+            suggested_checks: [
+                "Run representative happy-path execution.",
+                "Run malformed-input or failure-path execution where feasible.",
+            ],
+            source_artifacts: ["unit_manifest.json", "risk_register.json"],
+        });
+    }
+    if (criticalFlows && flowCoverage) {
+        const flowMap = new Map(criticalFlows.flows.map((flow) => [flow.id, flow]));
+        for (const record of flowCoverage.flows) {
+            if (record.status === "complete") {
+                continue;
+            }
+            const flow = flowMap.get(record.flow_id);
+            if (!flow) {
+                continue;
+            }
+            const id = `runtime:flow:${record.flow_id}`;
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            tasks.push({
+                id,
+                kind: "critical-flow-check",
+                target_paths: flow.paths,
+                reason: `Critical flow ${record.flow_id} is still ${record.status} and should receive runtime validation.`,
+                priority: record.status === "pending" ? "high" : "medium",
+                suggested_checks: checksForFlow(record.required_lenses),
+                source_artifacts: ["critical_flows.json", "flow_coverage.json"],
+            });
+        }
+    }
+    return { tasks };
+}
+export function buildPlaceholderRuntimeValidationReport(tasks) {
+    return {
+        results: tasks.tasks.map((task) => ({
+            task_id: task.id,
+            status: "pending",
+            summary: `No runtime evidence recorded yet for ${task.id}.`,
+            evidence: [],
+            notes: ["Placeholder entry generated from runtime validation task list."],
+        })),
+    };
+}
+export function mergeRuntimeValidationReport(tasks, existing) {
+    const existingMap = new Map((existing?.results ?? []).map((result) => [result.task_id, result]));
+    const mergedResults = tasks.tasks.map((task) => {
+        const prior = existingMap.get(task.id);
+        if (prior) {
+            return {
+                ...prior,
+                notes: [
+                    ...new Set([
+                        ...(prior.notes ?? []),
+                        "Preserved across runtime validation refresh.",
+                    ]),
+                ],
+            };
+        }
+        return {
+            task_id: task.id,
+            status: "pending",
+            summary: `No runtime evidence recorded yet for ${task.id}.`,
+            evidence: [],
+            notes: ["Placeholder entry generated from runtime validation task list."],
+        };
+    });
+    return { results: mergedResults };
+}

package/dist/orchestrator/runtimeValidationUpdate.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeValidationReport, RuntimeValidationTaskManifest } from "../types/runtimeValidation.js";
+export declare function updateRuntimeValidationReport(tasks: RuntimeValidationTaskManifest, existing: RuntimeValidationReport, updates: RuntimeValidationReport): RuntimeValidationReport;

package/dist/orchestrator/runtimeValidationUpdate.js

@@ -0,0 +1,52 @@
+function normalizeResult(result) {
+    return {
+        ...result,
+        evidence: [...new Set(result.evidence ?? [])],
+        notes: [...new Set(result.notes ?? [])],
+    };
+}
+export function updateRuntimeValidationReport(tasks, existing, updates) {
+    const validTaskIds = new Set(tasks.tasks.map((task) => task.id));
+    const merged = new Map();
+    for (const result of existing.results) {
+        if (!validTaskIds.has(result.task_id)) {
+            continue;
+        }
+        merged.set(result.task_id, normalizeResult(result));
+    }
+    for (const update of updates.results) {
+        if (!validTaskIds.has(update.task_id)) {
+            continue;
+        }
+        const prior = merged.get(update.task_id);
+        if (!prior) {
+            merged.set(update.task_id, normalizeResult(update));
+            continue;
+        }
+        merged.set(update.task_id, {
+            task_id: update.task_id,
+            status: update.status,
+            summary: update.summary,
+            evidence: [
+                ...new Set([...(prior.evidence ?? []), ...(update.evidence ?? [])]),
+            ],
+            notes: [...new Set([...(prior.notes ?? []), ...(update.notes ?? [])])],
+        });
+    }
+    for (const task of tasks.tasks) {
+        if (!merged.has(task.id)) {
+            merged.set(task.id, {
+                task_id: task.id,
+                status: "pending",
+                summary: `No runtime evidence recorded yet for ${task.id}.`,
+                evidence: [],
+                notes: [
+                    "Placeholder entry generated from runtime validation task list.",
+                ],
+            });
+        }
+    }
+    return {
+        results: [...merged.values()].sort((a, b) => a.task_id.localeCompare(b.task_id)),
+    };
+}

package/dist/orchestrator/staleness.d.ts

@@ -0,0 +1,2 @@
+import type { ArtifactBundle } from "../io/artifacts.js";
+export declare function computeStaleArtifacts(bundle: ArtifactBundle): Set<string>;

package/dist/orchestrator/staleness.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+import { getArtifactValue } from "../io/artifacts.js";
+import { ARTIFACT_DEPENDENCY_MAP } from "./dependencyMap.js";
+import { present } from "./artifactMetadata.js";
+function stableStringify(value) {
+    if (value === undefined)
+        return "null";
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableStringify(item ?? null)).join(",")}]`;
+    const entries = Object.entries(value)
+        .filter(([, item]) => item !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+}
+function normalizeForMetadataHash(artifactName, value) {
+    if (artifactName === "repo_manifest.json" &&
+        value &&
+        typeof value === "object" &&
+        !Array.isArray(value)) {
+        const record = value;
+        const { generated_at: _generatedAt, ...rest } = record;
+        return rest;
+    }
+    return value;
+}
+function computeContentHash(artifactName, bundle) {
+    const value = getArtifactValue(bundle, artifactName);
+    if (value === undefined || value === null)
+        return undefined;
+    return createHash("sha256")
+        .update(stableStringify(normalizeForMetadataHash(artifactName, value)))
+        .digest("hex");
+}
+export function computeStaleArtifacts(bundle) {
+    const stale = new Set();
+    const metadata = bundle.artifact_metadata;
+    if (metadata) {
+        for (const [artifactName, entry] of Object.entries(metadata.artifacts)) {
+            if (!present(bundle, artifactName))
+                continue;
+            let isStale = false;
+            for (const [dependencyName, recordedRevision] of Object.entries(entry.dependency_revisions)) {
+                if (!present(bundle, dependencyName)) {
+                    if (recordedRevision > 0) {
+                        isStale = true;
+                        break;
+                    }
+                    continue;
+                }
+                const dependencyEntry = metadata.artifacts[dependencyName];
+                if (!dependencyEntry) {
+                    if (recordedRevision > 0) {
+                        isStale = true;
+                        break;
+                    }
+                    continue;
+                }
+                const currentHash = computeContentHash(dependencyName, bundle);
+                if (!currentHash ||
+                    dependencyEntry.content_hash !== currentHash ||
+                    dependencyEntry.revision !== recordedRevision) {
+                    isStale = true;
+                    break;
+                }
+            }
+            if (isStale)
+                stale.add(artifactName);
+        }
+    }
+    for (const [upstream, downstreamList] of Object.entries(ARTIFACT_DEPENDENCY_MAP)) {
+        if (!present(bundle, upstream)) {
+            for (const downstream of downstreamList) {
+                const hasMetadataEntry = Boolean(metadata?.artifacts[downstream]);
+                if (present(bundle, downstream) && (!metadata || !hasMetadataEntry)) {
+                    stale.add(downstream);
+                }
+            }
+        }
+    }
+    return stale;
+}

package/dist/orchestrator/state.d.ts

@@ -0,0 +1,3 @@
+import type { ArtifactBundle } from "../io/artifacts.js";
+import type { AuditState } from "../types/auditState.js";
+export declare function deriveAuditState(bundle: ArtifactBundle): AuditState;

package/dist/orchestrator/state.js

@@ -0,0 +1,85 @@
+import { computeStaleArtifacts } from "./staleness.js";
+function has(value) {
+    return value !== undefined && value !== null;
+}
+function obligation(id, state, reason) {
+    return { id, state, reason };
+}
+function staleOrSatisfied(staleArtifacts, deps, present) {
+    if (!present)
+        return "missing";
+    return deps.some((dep) => staleArtifacts.has(dep)) ? "stale" : "satisfied";
+}
+export function deriveAuditState(bundle) {
+    const obligations = [];
+    const staleArtifacts = computeStaleArtifacts(bundle);
+    obligations.push(obligation("repo_manifest", has(bundle.repo_manifest) ? "satisfied" : "missing"));
+    obligations.push(obligation("file_disposition", staleOrSatisfied(staleArtifacts, ["file_disposition.json"], has(bundle.file_disposition))));
+    obligations.push(obligation("auto_fixes_applied", staleOrSatisfied(staleArtifacts, ["file_disposition.json"], has(bundle.auto_fixes_applied))));
+    obligations.push(obligation("syntax_resolved", staleOrSatisfied(staleArtifacts, ["auto_fixes_applied.json"], has(bundle.external_analyzer_results))));
+    const structureReady = has(bundle.unit_manifest) &&
+        has(bundle.surface_manifest) &&
+        has(bundle.graph_bundle) &&
+        has(bundle.critical_flows) &&
+        has(bundle.risk_register);
+    obligations.push(obligation("structure_artifacts", staleOrSatisfied(staleArtifacts, [
+        "unit_manifest.json",
+        "surface_manifest.json",
+        "graph_bundle.json",
+        "critical_flows.json",
+        "risk_register.json",
+    ], structureReady)));
+    const planningReady = has(bundle.coverage_matrix) &&
+        has(bundle.flow_coverage) &&
+        has(bundle.runtime_validation_tasks) &&
+        has(bundle.audit_tasks) &&
+        has(bundle.requeue_tasks);
+    obligations.push(obligation("planning_artifacts", staleOrSatisfied(staleArtifacts, [
+        "external_analyzer_results.json",
+        "coverage_matrix.json",
+        "flow_coverage.json",
+        "runtime_validation_tasks.json",
+        "audit_tasks.json",
+        "requeue_tasks.json",
+    ], planningReady)));
+    const hasRequiredCoverage = bundle.coverage_matrix?.files.every((f) => f.required_lenses.every((req) => f.completed_lenses.includes(req))) ?? true;
+    if (!hasRequiredCoverage &&
+        has(bundle.audit_tasks) &&
+        (bundle.audit_tasks?.length ?? 0) > 0) {
+        obligations.push(obligation("audit_tasks_completed", "missing"));
+    }
+    else if (hasRequiredCoverage && has(bundle.audit_tasks)) {
+        obligations.push(obligation("audit_tasks_completed", "satisfied"));
+    }
+    obligations.push(obligation("audit_results_ingested", has(bundle.audit_results) ? "present" : "missing"));
+    obligations.push(obligation("runtime_validation_current", staleOrSatisfied(staleArtifacts, ["runtime_validation_report.json"], has(bundle.runtime_validation_report))));
+    obligations.push(obligation("synthesis_current", staleOrSatisfied(staleArtifacts, [
+        "merged_findings.json",
+        "root_cause_clusters.json",
+        "synthesis_report.json",
+    ], has(bundle.merged_findings) &&
+        has(bundle.root_cause_clusters) &&
+        has(bundle.synthesis_report))));
+    let status = "not_started";
+    if (!has(bundle.repo_manifest)) {
+        status = "not_started";
+    }
+    else if (obligations.some((o) => o.state === "blocked")) {
+        status = "blocked";
+    }
+    else {
+        status = "active";
+    }
+    const incomplete = obligations.some((o) => o.state === "missing" || o.state === "stale");
+    if (!incomplete &&
+        has(bundle.synthesis_report) &&
+        has(bundle.merged_findings) &&
+        has(bundle.root_cause_clusters)) {
+        status = "complete";
+    }
+    return {
+        status,
+        blockers: [],
+        obligations,
+    };
+}

package/dist/orchestrator/syntaxResolutionExecutor.d.ts

@@ -0,0 +1,3 @@
+import type { ArtifactBundle } from "../io/artifacts.js";
+import type { ExecutorRunResult } from "./internalExecutors.js";
+export declare function runSyntaxResolutionExecutor(bundle: ArtifactBundle, root: string): ExecutorRunResult;

package/dist/orchestrator/syntaxResolutionExecutor.js

@@ -0,0 +1,99 @@
+import { execSync } from "node:child_process";
+function runTsc(root) {
+    const results = [];
+    try {
+        execSync("npx tsc --noEmit", {
+            cwd: root,
+            stdio: "pipe",
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        if (error.stdout) {
+            const output = error.stdout.toString();
+            const lines = output.split("\n");
+            for (const line of lines) {
+                const match = line.match(/^([^:]+)\((\d+),\d+\):\s+(error\s+TS\d+:.*)$/);
+                if (match) {
+                    results.push({
+                        id: `tsc-${results.length}`,
+                        category: "correctness",
+                        severity: "error",
+                        path: match[1].replace(/\\/g, "/"),
+                        summary: match[3],
+                        rule: "tsc",
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+function runEslint(root) {
+    const results = [];
+    try {
+        execSync("npx eslint . --ext .ts,.js,.tsx,.jsx --format json", {
+            cwd: root,
+            stdio: "pipe",
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        if (error.stdout) {
+            try {
+                const output = JSON.parse(error.stdout.toString());
+                for (const fileResult of output) {
+                    for (const msg of fileResult.messages) {
+                        results.push({
+                            id: `eslint-${results.length}`,
+                            category: "maintainability",
+                            severity: msg.severity === 2 ? "error" : "warning",
+                            path: fileResult.filePath
+                                .replace(/\\/g, "/")
+                                .replace(root.replace(/\\/g, "/") + "/", ""),
+                            summary: msg.message,
+                            rule: msg.ruleId || "eslint-error",
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                // failed to parse
+            }
+        }
+    }
+    return results;
+}
+export function runSyntaxResolutionExecutor(bundle, root) {
+    const items = [];
+    if (bundle.file_disposition?.files.some((f) => f.path.endsWith(".ts"))) {
+        items.push(...runTsc(root));
+    }
+    if (bundle.file_disposition?.files.some((f) => f.path.endsWith(".ts") || f.path.endsWith(".js"))) {
+        items.push(...runEslint(root));
+    }
+    const existing = bundle.external_analyzer_results?.results ?? [];
+    const merged = [...existing, ...items];
+    // Deduplicate by path + rule + summary
+    const seen = new Set();
+    const deduped = [];
+    for (const r of merged) {
+        const key = `${r.path}:${r.rule}:${r.summary}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            deduped.push(r);
+        }
+    }
+    const resultsArtifact = {
+        tool: "syntax_resolution_executor",
+        results: deduped,
+    };
+    return {
+        updated: {
+            ...bundle,
+            external_analyzer_results: resultsArtifact,
+        },
+        artifacts_written: ["external_analyzer_results.json"],
+        progress_summary: `Phase 2 Syntax Resolution complete. Extracted ${items.length} unfixable syntax/lint errors, triggering high-priority LLM resolution tasks.`,
+    };
+}

package/dist/orchestrator/taskBuilder.d.ts

@@ -0,0 +1,12 @@
+import type { ExternalAnalyzerResults } from "../types/externalAnalyzer.js";
+import type { AuditTask, CoverageMatrix, Lens, UnitManifest } from "../types.js";
+export interface UnitLineIndex {
+    [path: string]: number;
+}
+export interface BuildChunkedTaskOptions {
+    chunk_size?: number;
+    limit_lenses?: Lens[];
+    external_analyzer_results?: ExternalAnalyzerResults;
+}
+export declare function buildChunkedAuditTasks(unitManifest: UnitManifest, unitLineIndex: UnitLineIndex, options?: BuildChunkedTaskOptions): AuditTask[];
+export declare function buildExternalSignalTasks(coverageMatrix: CoverageMatrix, unitLineIndex: UnitLineIndex, externalAnalyzerResults?: ExternalAnalyzerResults): AuditTask[];