auditor-lambda 0.3.40 → 0.3.41

package/dist/cli/steps.d.ts

@@ -0,0 +1,29 @@
+import type { StepStatus } from "@audit-tools/shared";
+import type { AccessDeclaration } from "../types/workerSession.js";
+export declare const STEP_CONTRACT_VERSION = "audit-code-step/v1alpha1";
+export type StepKind = "dispatch_review" | "single_task_fallback" | "design_review" | "present_report" | "blocked";
+export interface StepArtifact {
+    contract_version: typeof STEP_CONTRACT_VERSION;
+    step_kind: StepKind;
+    prompt_path: string;
+    status: StepStatus;
+    run_id: string | null;
+    allowed_commands: string[];
+    stop_condition: string;
+    repo_root: string;
+    artifacts_dir: string;
+    artifact_paths: Record<string, string | null>;
+    access?: AccessDeclaration;
+}
+export declare function writeCurrentStep(params: {
+    artifactsDir: string;
+    stepKind: StepKind;
+    status: StepStatus;
+    runId: string | null;
+    allowedCommands: string[];
+    stopCondition: string;
+    repoRoot: string;
+    artifactPaths: Record<string, string | null>;
+    prompt: string;
+    access?: AccessDeclaration;
+}): Promise<StepArtifact>;

package/dist/cli/steps.js

@@ -0,0 +1,30 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { writeJsonFile } from "@audit-tools/shared";
+export const STEP_CONTRACT_VERSION = "audit-code-step/v1alpha1";
+export async function writeCurrentStep(params) {
+    const stepsDir = join(params.artifactsDir, "steps");
+    await mkdir(stepsDir, { recursive: true });
+    const promptPath = join(stepsDir, "current-prompt.md");
+    const stepPath = join(stepsDir, "current-step.json");
+    await writeFile(promptPath, params.prompt, "utf8");
+    const step = {
+        contract_version: STEP_CONTRACT_VERSION,
+        step_kind: params.stepKind,
+        prompt_path: promptPath,
+        status: params.status,
+        run_id: params.runId,
+        allowed_commands: params.allowedCommands,
+        stop_condition: params.stopCondition,
+        repo_root: params.repoRoot,
+        artifacts_dir: params.artifactsDir,
+        artifact_paths: {
+            current_step: stepPath,
+            current_prompt: promptPath,
+            ...params.artifactPaths,
+        },
+        ...(params.access ? { access: params.access } : {}),
+    };
+    await writeJsonFile(stepPath, step);
+    return step;
+}

package/dist/cli/waveManifest.d.ts

@@ -0,0 +1,40 @@
+import type { AuditTask } from "../types.js";
+declare const WAVE_MANIFEST_CONTRACT = "audit-code-wave/v1alpha1";
+export interface WaveSlotEntry {
+    run_id: string;
+    task_path: string;
+    prompt_path: string;
+    result_path: string;
+    stdout_path: string;
+    stderr_path: string;
+    status_path: string;
+    audit_results_path: string;
+    pending_tasks_path: string;
+    task_ids: string[];
+}
+export interface WaveManifest {
+    contract_version: typeof WAVE_MANIFEST_CONTRACT;
+    obligation_id: string;
+    started_at: string;
+    pid: number;
+    slots: WaveSlotEntry[];
+}
+export declare function waveManifestPath(artifactsDir: string): string;
+export declare function writeWaveManifest(artifactsDir: string, manifest: Omit<WaveManifest, "contract_version">): Promise<void>;
+export declare function readWaveManifest(artifactsDir: string): Promise<WaveManifest | null>;
+export declare function removeWaveManifest(artifactsDir: string): Promise<void>;
+export declare function buildWaveSlotEntry(slot: {
+    runId: string;
+    paths: {
+        taskPath: string;
+        promptPath: string;
+        resultPath: string;
+        stdoutPath: string;
+        stderrPath: string;
+        statusPath: string;
+    };
+    auditResultsPath: string;
+    pendingTasksPath: string;
+    group: AuditTask[];
+}): WaveSlotEntry;
+export {};

package/dist/cli/waveManifest.js

@@ -0,0 +1,41 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { isFileMissingError, readJsonFile, writeJsonFile } from "@audit-tools/shared";
+const WAVE_MANIFEST_FILENAME = "wave-manifest.json";
+const WAVE_MANIFEST_CONTRACT = "audit-code-wave/v1alpha1";
+export function waveManifestPath(artifactsDir) {
+    return join(artifactsDir, "dispatch", WAVE_MANIFEST_FILENAME);
+}
+export async function writeWaveManifest(artifactsDir, manifest) {
+    await writeJsonFile(waveManifestPath(artifactsDir), {
+        contract_version: WAVE_MANIFEST_CONTRACT,
+        ...manifest,
+    });
+}
+export async function readWaveManifest(artifactsDir) {
+    try {
+        return await readJsonFile(waveManifestPath(artifactsDir));
+    }
+    catch (error) {
+        if (isFileMissingError(error))
+            return null;
+        throw error;
+    }
+}
+export async function removeWaveManifest(artifactsDir) {
+    await rm(waveManifestPath(artifactsDir), { force: true });
+}
+export function buildWaveSlotEntry(slot) {
+    return {
+        run_id: slot.runId,
+        task_path: slot.paths.taskPath,
+        prompt_path: slot.paths.promptPath,
+        result_path: slot.paths.resultPath,
+        stdout_path: slot.paths.stdoutPath,
+        stderr_path: slot.paths.stderrPath,
+        status_path: slot.paths.statusPath,
+        audit_results_path: slot.auditResultsPath,
+        pending_tasks_path: slot.pendingTasksPath,
+        task_ids: slot.group.map((t) => t.task_id),
+    };
+}

package/dist/cli/workerResult.d.ts

@@ -0,0 +1,18 @@
+import type { WorkerResult } from "../types/workerResult.js";
+import type { RunPaths } from "../io/runArtifacts.js";
+export declare const WORKER_RESULT_CONTRACT_VERSION = "audit-code-worker-result/v1alpha1";
+export declare function buildWorkerResult(params: {
+    runId: string;
+    obligationId: string | null;
+    status: WorkerResult["status"];
+    progressMade: boolean;
+    selectedExecutor: string | null;
+    artifactsWritten: string[];
+    summary: string;
+    nextLikelyStep: string | null;
+    errors: string[];
+}): WorkerResult;
+export declare function persistWorkerRunArtifacts(paths: RunPaths, workerResult: WorkerResult, executionMode: string): Promise<void>;
+export declare function isWorkerResult(value: unknown): value is WorkerResult;
+export declare function buildWorkerFailureBlocker(workerResult: WorkerResult): string;
+export declare function formatAuditResultValidationError(issues: ReturnType<typeof import("../validation/auditResults.js").validateAuditResults>): string;

package/dist/cli/workerResult.js

@@ -0,0 +1,42 @@
+import { writeJsonFile } from "@audit-tools/shared";
+import { formatAuditResultIssues } from "../validation/auditResults.js";
+export const WORKER_RESULT_CONTRACT_VERSION = "audit-code-worker-result/v1alpha1";
+export function buildWorkerResult(params) {
+    return {
+        contract_version: WORKER_RESULT_CONTRACT_VERSION,
+        run_id: params.runId,
+        obligation_id: params.obligationId,
+        status: params.status,
+        progress_made: params.progressMade,
+        selected_executor: params.selectedExecutor,
+        artifacts_written: params.artifactsWritten,
+        summary: params.summary,
+        next_likely_step: params.nextLikelyStep,
+        errors: params.errors,
+    };
+}
+export async function persistWorkerRunArtifacts(paths, workerResult, executionMode) {
+    await writeJsonFile(paths.resultPath, workerResult);
+    await writeJsonFile(paths.statusPath, {
+        run_id: workerResult.run_id,
+        status: workerResult.status,
+        execution_mode: executionMode,
+        result_path: paths.resultPath,
+    });
+}
+export function isWorkerResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.contract_version ===
+            WORKER_RESULT_CONTRACT_VERSION);
+}
+export function buildWorkerFailureBlocker(workerResult) {
+    const details = workerResult.errors.filter((error) => error.trim().length > 0);
+    return details.length > 0
+        ? `${workerResult.summary} ${details.join(" ")}`
+        : workerResult.summary;
+}
+export function formatAuditResultValidationError(issues) {
+    return (`audit-results validation failed with ${issues.length} error(s):\n` +
+        formatAuditResultIssues(issues));
+}

package/dist/cli.d.ts

@@ -1,24 +1,5 @@
-import type { SessionConfig } from "./types/sessionConfig.js";
-type UiMode = "visible" | "headless";
-declare function getFlag(argv: string[], name: string, fallback?: string): string | undefined;
-declare function hasFlag(argv: string[], name: string): boolean;
-export declare function resolveHostDispatchCapability(options: {
-    explicit?: boolean;
-    sessionConfig: SessionConfig;
-    env?: NodeJS.ProcessEnv;
-}): boolean;
-declare function getArtifactsDir(argv: string[]): string;
-declare function getRootDir(argv: string[]): string;
-declare function warnIfNotGitRepo(root: string): void;
-declare function getBatchResultsDir(argv: string[]): string | undefined;
-declare function getMaxRuns(argv: string[]): number;
-declare function getAgentBatchSize(argv: string[], sessionConfig: SessionConfig): number;
-declare function getParallelWorkers(argv: string[], sessionConfig: SessionConfig): number;
-declare function getTimeoutMs(argv: string[], sessionConfig: SessionConfig): number;
-declare function chunkArray<T>(arr: T[], size: number): T[][];
-declare function getUiMode(argv: string[], fallback?: UiMode): UiMode;
-declare function countLines(path: string): Promise<number>;
-declare function looksLikeCliFlag(value: string | undefined): boolean;
+export { resolveHostDispatchCapability, DIRECT_CLI_DEFAULTS, getFlag, hasFlag, getOptionalBooleanFlag, getArtifactsDir, getRootDir, getBatchResultsDir, getMaxRuns, getAgentBatchSize, getParallelWorkers, getTimeoutMs, chunkArray, getUiMode, looksLikeCliFlag, countLines, warnIfNotGitRepo, } from "./cli/args.js";
+import { type UiMode, getFlag, hasFlag, getArtifactsDir, getRootDir, warnIfNotGitRepo, getBatchResultsDir, getMaxRuns, getAgentBatchSize, getParallelWorkers, getTimeoutMs, chunkArray, getUiMode, looksLikeCliFlag, countLines } from "./cli/args.js";
 export declare const cliTestUtils: {
     defaults: {
         rootDir: string;
@@ -46,4 +27,3 @@ export declare const cliTestUtils: {
 };
 export declare function runSample(argv?: string[]): Promise<void>;
 export declare function runCli(argv: string[]): Promise<void>;
-export {};