auditor-lambda 0.6.12 → 0.8.0

package/dist/orchestrator/graphEnrichmentExecutor.js

@@ -133,7 +133,9 @@ export async function runGraphEnrichmentExecutor(bundle, options = {}) {
                 setting,
                 edges_added: 0,
                 routes_added: 0,
-                note: `Analyzer failed: ${error instanceof Error ? error.message : String(error)}.`,
+                note: error instanceof Error
+                    ? `Analyzer failed [${error.name}]: ${error.message}${error.stack ? ` — stack: ${error.stack.split("\n").slice(0, 4).join(" | ")}` : ""}`
+                    : `Analyzer failed: ${String(error)}.`,
             });
             continue;
         }

package/dist/orchestrator/internalExecutors.d.ts

@@ -3,16 +3,7 @@ import type { AuditResult } from "../types.js";
 import type { RuntimeValidationReport } from "../types/runtimeValidation.js";
 import type { ExternalAnalyzerResults } from "../types/externalAnalyzer.js";
 import type { AuditScopeManifest } from "../types/auditScope.js";
-import type { SynthesisNarrative } from "@audit-tools/shared";
-export interface ExecutorRunResult {
-    updated: ArtifactBundle;
-    artifacts_written: string[];
-    progress_summary: string;
-}
-export declare function resolveRuntimeValidationSpawnCommand(command: string[], platform?: NodeJS.Platform, shellCommand?: string): {
-    command: string;
-    args: string[];
-};
+import type { ExecutorRunResult } from "./executorResult.js";
 export declare function runIntakeExecutor(bundle: ArtifactBundle, root: string): Promise<ExecutorRunResult>;
 export declare function runStructureExecutor(bundle: ArtifactBundle, root?: string): Promise<ExecutorRunResult>;
 export declare function runDesignAssessmentExecutor(bundle: ArtifactBundle): ExecutorRunResult;
@@ -23,12 +14,4 @@ export declare function runRuntimeValidationExecutor(bundle: ArtifactBundle, roo
     opentoken?: boolean;
 }): Promise<ExecutorRunResult>;
 export declare function runRuntimeValidationUpdateExecutor(bundle: ArtifactBundle, updates: RuntimeValidationReport): ExecutorRunResult;
-export declare function runSynthesisExecutor(bundle: ArtifactBundle, results?: AuditResult[]): ExecutorRunResult;
-/**
- * Resolve the optional synthesis-narrative obligation. When a host/provider
- * narrative is supplied it is merged into the canonical findings report and the
- * human report is re-rendered with themes/executive-summary/top-risks; without
- * one the narrative is recorded as omitted and the deterministic report stands.
- */
-export declare function runSynthesisNarrativeExecutor(bundle: ArtifactBundle, narrative?: SynthesisNarrative): ExecutorRunResult;
 export declare function runExternalAnalyzerImportExecutor(bundle: ArtifactBundle, externalResults: ExternalAnalyzerResults): ExecutorRunResult;

package/dist/orchestrator/internalExecutors.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { runCommand } from "./runtimeCommand.js";
 import { buildFileDisposition, isAuditExcludedStatus, } from "../extractors/disposition.js";
 import { buildGraphBundle, buildGraphBundleFromFs, } from "../extractors/graph.js";
 import { buildCriticalFlowManifest } from "../extractors/flows.js";
@@ -9,7 +9,6 @@ import { applyScopeToCoverage, fullAuditScope } from "./scope.js";
 import { buildFlowCoverage } from "./flowCoverage.js";
 import { buildRequeuePayload } from "./requeueCommand.js";
 import { buildRuntimeValidationTasks, discoverRuntimeValidationCommand, mergeRuntimeValidationReport, } from "./runtimeValidation.js";
-import { applyNarrative, buildAuditFindingsReport, buildAuditReportModel, renderAuditReportMarkdown, } from "../reporting/synthesis.js";
 import { buildChunkedAuditTasks, } from "./taskBuilder.js";
 import { buildAuditPlanMetrics, buildReviewPackets, sizeIndexFromManifest, } from "./reviewPackets.js";
 import { buildUnitManifest } from "./unitBuilder.js";
@@ -60,79 +59,6 @@ function appendSelectiveDeepeningTasks(params) {
         artifacts: ["audit_tasks.json", "audit_plan_metrics.json", "review_packets.json"],
     };
 }
-function resolveOpentokenWrap(resolved, platform = process.platform) {
-    if (platform === "win32") {
-        const shell = process.env.ComSpec ?? "cmd.exe";
-        const inner = [resolved.command, ...resolved.args]
-            .map((v) => (/^[A-Za-z0-9_./:=@+-]+$/.test(v) ? v : `"${v.replace(/(["^&|<>%])/g, "^$1")}"`))
-            .join(" ");
-        return { command: shell, args: ["/d", "/s", "/c", `opentoken wrap ${inner}`] };
-    }
-    return { command: "opentoken", args: ["wrap", resolved.command, ...resolved.args] };
-}
-async function runCommand(command, cwd, options = {}) {
-    let spawnCommand = resolveRuntimeValidationSpawnCommand(command);
-    if (options.opentoken) {
-        spawnCommand = resolveOpentokenWrap(spawnCommand);
-    }
-    const displayCommand = command.join(" ");
-    return await new Promise((resolve) => {
-        const child = spawn(spawnCommand.command, spawnCommand.args, {
-            cwd,
-            env: process.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += String(chunk);
-        });
-        child.on("error", (error) => {
-            resolve({
-                status: "inconclusive",
-                summary: `Failed to execute ${displayCommand}: ${error.message}`,
-                evidence: [],
-            });
-        });
-        child.on("exit", (code) => {
-            const output = `${stdout}\n${stderr}`.trim();
-            const evidence = output.length > 0 ? output.split(/\r?\n/).slice(-10) : [];
-            resolve({
-                status: code === 0 ? "confirmed" : "not_confirmed",
-                summary: code === 0
-                    ? `Deterministic runtime command succeeded: ${displayCommand}`
-                    : `Deterministic runtime command failed with exit code ${code}: ${displayCommand}`,
-                evidence,
-            });
-        });
-    });
-}
-export function resolveRuntimeValidationSpawnCommand(command, platform = process.platform, shellCommand = process.env.ComSpec ?? "cmd.exe") {
-    const [executable, ...args] = command;
-    if (!executable) {
-        return { command: "", args: [] };
-    }
-    if (platform !== "win32") {
-        return { command: executable, args };
-    }
-    const packageManager = executable.replace(/\.(cmd|bat)$/i, "").toLowerCase();
-    if (["npm", "npx", "pnpm", "yarn"].includes(packageManager)) {
-        return {
-            command: shellCommand,
-            args: ["/d", "/s", "/c", command.map(quoteCmdArg).join(" ")],
-        };
-    }
-    return { command: executable, args };
-}
-function quoteCmdArg(value) {
-    if (/^[A-Za-z0-9_./:=+-]+$/.test(value)) {
-        return value;
-    }
-    return `"${value.replace(/(["^&|<>%])/g, "^$1")}"`;
-}
 export async function runIntakeExecutor(bundle, root) {
     const ignore = await loadIgnoreFile(root);
     const repoManifest = await buildRepoManifestFromFs({
@@ -476,89 +402,6 @@ export function runRuntimeValidationUpdateExecutor(bundle, updates) {
                 : ""),
     };
 }
-function buildBaseFindingsReport(bundle, results) {
-    return buildAuditFindingsReport(buildAuditReportModel({
-        results,
-        unitManifest: bundle.unit_manifest,
-        graphBundle: bundle.graph_bundle,
-        criticalFlows: bundle.critical_flows,
-        coverageMatrix: bundle.coverage_matrix,
-        runtimeValidationReport: bundle.runtime_validation_report,
-        externalAnalyzerResults: bundle.external_analyzer_results,
-        designAssessment: bundle.design_assessment,
-    }));
-}
-export function runSynthesisExecutor(bundle, results) {
-    const finalResults = results ?? bundle.audit_results ?? [];
-    // Emit the canonical machine contract and render the human report from it.
-    // No narrative yet — that is layered by the synthesis-narrative obligation.
-    const findings = buildBaseFindingsReport(bundle, finalResults);
-    return {
-        updated: {
-            ...bundle,
-            audit_results: finalResults,
-            audit_findings: findings,
-            audit_report: renderAuditReportMarkdown(findings, { scope: bundle.scope }),
-        },
-        artifacts_written: ["audit-findings.json", "audit-report.md"],
-        progress_summary: `Rendered deterministic audit report and canonical findings for ${finalResults.length} audit result entries.`,
-    };
-}
-/**
- * Resolve the optional synthesis-narrative obligation. When a host/provider
- * narrative is supplied it is merged into the canonical findings report and the
- * human report is re-rendered with themes/executive-summary/top-risks; without
- * one the narrative is recorded as omitted and the deterministic report stands.
- */
-export function runSynthesisNarrativeExecutor(bundle, narrative) {
-    const baseReport = bundle.audit_findings ??
-        buildBaseFindingsReport(bundle, bundle.audit_results ?? []);
-    const needsBaseWrite = !bundle.audit_findings;
-    const hasNarrative = Boolean(narrative &&
-        ((narrative.themes?.length ?? 0) > 0 ||
-            (narrative.executive_summary?.trim().length ?? 0) > 0 ||
-            (narrative.top_risks?.length ?? 0) > 0));
-    if (!hasNarrative) {
-        const record = {
-            status: "omitted",
-            theme_count: 0,
-            executive_summary_present: false,
-            top_risk_count: 0,
-        };
-        return {
-            updated: {
-                ...bundle,
-                audit_findings: baseReport,
-                synthesis_narrative: record,
-            },
-            artifacts_written: needsBaseWrite
-                ? ["audit-findings.json", "synthesis-narrative.json"]
-                : ["synthesis-narrative.json"],
-            progress_summary: "Synthesis narrative omitted; deterministic findings report retained.",
-        };
-    }
-    const enriched = applyNarrative(baseReport, narrative);
-    const record = {
-        status: "applied",
-        theme_count: enriched.themes?.length ?? 0,
-        executive_summary_present: (enriched.executive_summary?.trim().length ?? 0) > 0,
-        top_risk_count: enriched.top_risks?.length ?? 0,
-    };
-    return {
-        updated: {
-            ...bundle,
-            audit_findings: enriched,
-            audit_report: renderAuditReportMarkdown(enriched, { scope: bundle.scope }),
-            synthesis_narrative: record,
-        },
-        artifacts_written: [
-            "audit-findings.json",
-            "audit-report.md",
-            "synthesis-narrative.json",
-        ],
-        progress_summary: `Synthesis narrative applied: ${record.theme_count} theme(s), ${record.top_risk_count} top risk(s).`,
-    };
-}
 export function runExternalAnalyzerImportExecutor(bundle, externalResults) {
     const summary = `Imported ${externalResults.results.length} normalized findings from ${externalResults.tool}.`;
     return {

package/dist/orchestrator/reviewPacketGraph.d.ts

@@ -0,0 +1,31 @@
+import type { AuditTask } from "../types.js";
+import type { ReviewPacketGraphEdge, ReviewPacketQuality } from "../types/reviewPlanning.js";
+import type { GraphBundle, GraphEdge } from "@audit-tools/shared";
+import { UnionFind } from "./unionFind.js";
+import { normalizeGraphPath } from "../extractors/graphPathUtils.js";
+export { normalizeGraphPath };
+/**
+ * Fan-in / fan-out degree above which a node is treated as a hub. Exported so
+ * the Phase 3 delta-scope expansion skips the same hubs that packet planning
+ * skips, preventing scope blow-up through highly-connected modules.
+ */
+export declare const HIGH_FAN_DEGREE_THRESHOLD = 12;
+export declare function collectGraphEdges(graphBundle?: GraphBundle): GraphEdge[];
+export declare function graphEdgeConfidence(edge: GraphEdge): number;
+export declare function isConcreteGraphEdge(edge: GraphEdge): boolean;
+export interface GraphDegreeIndex {
+    fanIn: Map<string, number>;
+    fanOut: Map<string, number>;
+}
+export declare function buildGraphDegreeIndex(edges: GraphEdge[]): GraphDegreeIndex;
+export declare function isPacketExpansionEdge(edge: GraphEdge, degreeIndex: GraphDegreeIndex): boolean;
+export declare function buildFileToGroupKeys(groups: Map<string, AuditTask[]>): Map<string, Set<string>>;
+export declare function unionFindFromGroups(groups: Map<string, AuditTask[]>, graphEdges: GraphEdge[]): UnionFind;
+export declare function buildPlanningGraphEdges(groups: Map<string, AuditTask[]>, graphEdges: GraphEdge[], graphBundle?: GraphBundle, lineIndex?: Record<string, number>, sizeIndex?: Record<string, number>, targetPacketTokens?: number): GraphEdge[];
+export declare function roundQuality(value: number): number;
+export declare function buildPacketGraphContext(filePaths: string[], graphEdges: GraphEdge[], graphBundle?: GraphBundle): {
+    keyEdges: ReviewPacketGraphEdge[];
+    boundaryFiles: string[];
+    entrypoints: string[];
+    quality: ReviewPacketQuality;
+};