auditor-lambda 0.3.40 → 0.5.0

package/dist/io/json.js

@@ -1,142 +0,0 @@
-import { mkdir, readFile, writeFile, appendFile } from "node:fs/promises";
-import { dirname } from "node:path";
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function ioError(action, path, error) {
-    return new Error(`Failed to ${action} ${path}: ${errorMessage(error)}`);
-}
-async function ensureParentDirectory(path) {
-    try {
-        await mkdir(dirname(path), { recursive: true });
-    }
-    catch (error) {
-        throw ioError("prepare parent directory", path, error);
-    }
-}
-export function isFileMissingError(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === "ENOENT");
-}
-export async function readJsonFile(path) {
-    let content;
-    try {
-        content = await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (isFileMissingError(error)) {
-            throw error;
-        }
-        throw ioError("read", path, error);
-    }
-    try {
-        return JSON.parse(content);
-    }
-    catch (error) {
-        throw new Error(`Invalid JSON in ${path}: ${errorMessage(error)}`);
-    }
-}
-export async function writeJsonFile(path, value) {
-    await ensureParentDirectory(path);
-    try {
-        await writeFile(path, JSON.stringify(value, null, 2) + "\n", "utf8");
-    }
-    catch (error) {
-        throw ioError("write", path, error);
-    }
-}
-export async function appendNdjsonFile(path, value) {
-    await ensureParentDirectory(path);
-    try {
-        await appendFile(path, JSON.stringify(value) + "\n", "utf8");
-    }
-    catch (error) {
-        throw ioError("append", path, error);
-    }
-}
-export async function readNdjsonFile(path) {
-    try {
-        const content = await readFile(path, "utf8");
-        const values = [];
-        let sawContent = false;
-        for (const [index, line] of content.split(/\r?\n/).entries()) {
-            if (line.trim().length === 0) {
-                continue;
-            }
-            sawContent = true;
-            try {
-                values.push(JSON.parse(line));
-            }
-            catch (error) {
-                throw new Error(`Invalid NDJSON in ${path} at line ${index + 1}: ${errorMessage(error)}`);
-            }
-        }
-        return sawContent ? values : [];
-    }
-    catch (error) {
-        if (isFileMissingError(error)) {
-            throw error;
-        }
-        if (error instanceof Error && error.message.includes(path)) {
-            throw error;
-        }
-        throw ioError("read", path, error);
-    }
-}
-export async function readOptionalJsonFile(path) {
-    try {
-        return await readJsonFile(path);
-    }
-    catch (error) {
-        if (isFileMissingError(error)) {
-            return undefined;
-        }
-        throw error;
-    }
-}
-export async function readOptionalNdjsonFile(path) {
-    try {
-        return await readNdjsonFile(path);
-    }
-    catch (error) {
-        if (isFileMissingError(error)) {
-            return undefined;
-        }
-        throw error;
-    }
-}
-export async function writeNdjsonFile(path, values) {
-    await ensureParentDirectory(path);
-    try {
-        if (values.length === 0) {
-            await writeFile(path, "", "utf8");
-            return;
-        }
-        await writeFile(path, values.map((v) => JSON.stringify(v)).join("\n") + "\n", "utf8");
-    }
-    catch (error) {
-        throw ioError("write", path, error);
-    }
-}
-export async function readOptionalTextFile(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (isFileMissingError(error)) {
-            return undefined;
-        }
-        throw ioError("read", path, error);
-    }
-}
-export async function writeTextFile(path, value) {
-    await ensureParentDirectory(path);
-    try {
-        await writeFile(path, value, "utf8");
-    }
-    catch (error) {
-        throw ioError("write", path, error);
-    }
-}

package/dist/providers/types.d.ts

@@ -1,33 +0,0 @@
-export interface LaunchFreshSessionInput {
-    repoRoot: string;
-    runId: string;
-    obligationId: string | null;
-    promptPath: string;
-    taskPath: string;
-    resultPath: string;
-    stdoutPath: string;
-    stderrPath: string;
-    uiMode: "visible" | "headless";
-    timeoutMs: number;
-}
-export interface LaunchFreshSessionResult {
-    accepted: boolean;
-    processId?: number;
-    exitCode?: number | null;
-    signal?: string | null;
-    command?: string;
-    args?: string[];
-    stdoutPath?: string;
-    stderrPath?: string;
-    error?: string;
-}
-export interface ProviderRateLimits {
-    requests_per_minute?: number | null;
-    input_tokens_per_minute?: number | null;
-    output_tokens_per_minute?: number | null;
-}
-export interface FreshSessionProvider {
-    name: string;
-    launch(input: LaunchFreshSessionInput): Promise<LaunchFreshSessionResult>;
-    queryLimits?(model: string | null): Promise<ProviderRateLimits | null>;
-}

package/dist/quota/compositeQuotaSource.d.ts

@@ -1,7 +0,0 @@
-import type { QuotaSource, QuotaUsageSnapshot } from "./quotaSource.js";
-export declare class CompositeQuotaSource implements QuotaSource {
-    readonly name = "composite";
-    private sources;
-    constructor(sources: QuotaSource[]);
-    queryCurrentUsage(providerModelKey: string): Promise<QuotaUsageSnapshot | null>;
-}

package/dist/quota/compositeQuotaSource.js

@@ -1,20 +0,0 @@
-export class CompositeQuotaSource {
-    name = "composite";
-    sources;
-    constructor(sources) {
-        this.sources = sources;
-    }
-    async queryCurrentUsage(providerModelKey) {
-        for (const source of this.sources) {
-            try {
-                const snapshot = await source.queryCurrentUsage(providerModelKey);
-                if (snapshot)
-                    return snapshot;
-            }
-            catch {
-                // Skip failing sources, try next
-            }
-        }
-        return null;
-    }
-}

package/dist/quota/errorParsers/claudeCodeErrorParser.d.ts

@@ -1,6 +0,0 @@
-import type { RateLimitDetectionResult } from "../errorParsing.js";
-import type { ErrorParser } from "./genericErrorParser.js";
-export declare class ClaudeCodeErrorParser implements ErrorParser {
-    readonly name = "claude-code";
-    parse(text: string): RateLimitDetectionResult;
-}

package/dist/quota/errorParsers/claudeCodeErrorParser.js

@@ -1,39 +0,0 @@
-export class ClaudeCodeErrorParser {
-    name = "claude-code";
-    parse(text) {
-        for (const line of text.split("\n")) {
-            const trimmed = line.trim();
-            if (!trimmed.startsWith("{"))
-                continue;
-            try {
-                const obj = JSON.parse(trimmed);
-                const level = obj["level"];
-                const type = obj["type"];
-                const message = obj["message"] ?? "";
-                const statusCode = obj["status_code"];
-                if (statusCode === 429 ||
-                    type === "rate_limit_error" ||
-                    (level === "error" && /\brate.?limit/i.test(message))) {
-                    const retryAfter = obj["retry_after"];
-                    const retryAfterMs = obj["retry_after_ms"];
-                    let extractedMs = null;
-                    if (retryAfterMs != null && retryAfterMs > 0) {
-                        extractedMs = retryAfterMs;
-                    }
-                    else if (retryAfter != null && retryAfter > 0) {
-                        extractedMs = retryAfter < 600 ? retryAfter * 1000 : retryAfter;
-                    }
-                    return {
-                        isRateLimited: true,
-                        retryAfterMs: extractedMs,
-                        rawMatch: `claude-code-stderr:${statusCode ?? type ?? "rate_limit"}`,
-                    };
-                }
-            }
-            catch {
-                // Not valid JSON, skip
-            }
-        }
-        return { isRateLimited: false, retryAfterMs: null, rawMatch: null };
-    }
-}

package/dist/quota/errorParsers/genericErrorParser.d.ts

@@ -1,9 +0,0 @@
-import type { RateLimitDetectionResult } from "../errorParsing.js";
-export interface ErrorParser {
-    readonly name: string;
-    parse(text: string): RateLimitDetectionResult;
-}
-export declare class GenericErrorParser implements ErrorParser {
-    readonly name = "generic";
-    parse(text: string): RateLimitDetectionResult;
-}

package/dist/quota/errorParsers/genericErrorParser.js

@@ -1,7 +0,0 @@
-import { detectRateLimitError } from "../errorParsing.js";
-export class GenericErrorParser {
-    name = "generic";
-    parse(text) {
-        return detectRateLimitError(text);
-    }
-}

package/dist/quota/errorParsers/index.d.ts

@@ -1,5 +0,0 @@
-export type { ErrorParser } from "./genericErrorParser.js";
-export { GenericErrorParser } from "./genericErrorParser.js";
-export { ClaudeCodeErrorParser } from "./claudeCodeErrorParser.js";
-import type { ErrorParser } from "./genericErrorParser.js";
-export declare function getErrorParserForProvider(providerName: string): ErrorParser;

package/dist/quota/errorParsers/index.js

@@ -1,12 +0,0 @@
-export { GenericErrorParser } from "./genericErrorParser.js";
-export { ClaudeCodeErrorParser } from "./claudeCodeErrorParser.js";
-import { GenericErrorParser } from "./genericErrorParser.js";
-import { ClaudeCodeErrorParser } from "./claudeCodeErrorParser.js";
-const PROVIDER_PARSERS = {
-    "claude-code": () => new ClaudeCodeErrorParser(),
-};
-const genericParser = new GenericErrorParser();
-export function getErrorParserForProvider(providerName) {
-    const factory = PROVIDER_PARSERS[providerName];
-    return factory ? factory() : genericParser;
-}

package/dist/quota/errorParsing.d.ts

@@ -1,7 +0,0 @@
-export interface RateLimitDetectionResult {
-    isRateLimited: boolean;
-    retryAfterMs: number | null;
-    rawMatch: string | null;
-}
-export declare function detectRateLimitError(text: string): RateLimitDetectionResult;
-export declare function computeCooldownUntil(retryAfterMs: number | null, defaultMs?: number): string;

package/dist/quota/errorParsing.js

@@ -1,69 +0,0 @@
-const RATE_LIMIT_PATTERNS = [
-    /\b429\b/i,
-    /\btoo many requests\b/i,
-    /\brate.?limit/i,
-    /\boverloaded\b/i,
-    /\bresource.?exhausted\b/i,
-    /\bquota.?exceeded\b/i,
-];
-function tryParseJson(text) {
-    const jsonStart = text.indexOf("{");
-    if (jsonStart === -1)
-        return null;
-    try {
-        return JSON.parse(text.slice(jsonStart));
-    }
-    catch {
-        return null;
-    }
-}
-function extractRetryAfterMs(obj) {
-    const headers = obj["headers"];
-    const retryAfter = headers?.["retry-after"] ??
-        headers?.["Retry-After"] ??
-        obj["retry_after"] ??
-        obj["retry_after_ms"];
-    if (retryAfter == null)
-        return null;
-    const val = typeof retryAfter === "string" ? Number(retryAfter) : retryAfter;
-    if (!Number.isFinite(val) || val <= 0)
-        return null;
-    // If the value looks like seconds (< 600), convert to ms
-    return val < 600 ? val * 1000 : val;
-}
-function detectFromJson(text) {
-    const obj = tryParseJson(text);
-    if (!obj)
-        return null;
-    const status = obj["status"];
-    const type = obj["type"];
-    const errorObj = obj["error"];
-    const errorType = errorObj?.["type"];
-    const isRateLimited = status === 429 ||
-        type === "rate_limit_error" ||
-        errorType === "rate_limit_error";
-    if (!isRateLimited)
-        return null;
-    return {
-        isRateLimited: true,
-        retryAfterMs: extractRetryAfterMs(obj),
-        rawMatch: `json:${status === 429 ? "status=429" : `type=${type ?? errorType}`}`,
-    };
-}
-export function detectRateLimitError(text) {
-    const jsonResult = detectFromJson(text);
-    if (jsonResult)
-        return jsonResult;
-    for (const pattern of RATE_LIMIT_PATTERNS) {
-        const match = pattern.exec(text);
-        if (match) {
-            return { isRateLimited: true, retryAfterMs: null, rawMatch: match[0] };
-        }
-    }
-    return { isRateLimited: false, retryAfterMs: null, rawMatch: null };
-}
-const DEFAULT_COOLDOWN_MS = 60_000;
-export function computeCooldownUntil(retryAfterMs, defaultMs = DEFAULT_COOLDOWN_MS) {
-    const ms = retryAfterMs != null && retryAfterMs > 0 ? retryAfterMs : defaultMs;
-    return new Date(Date.now() + ms).toISOString();
-}

package/dist/quota/fileLock.d.ts

@@ -1,6 +0,0 @@
-export declare class FileLockTimeoutError extends Error {
-    constructor(lockPath: string);
-}
-export declare function acquireLock(lockPath: string, timeoutMs?: number): Promise<void>;
-export declare function releaseLock(lockPath: string): Promise<void>;
-export declare function withFileLock<T>(lockPath: string, fn: () => Promise<T>, timeoutMs?: number): Promise<T>;

package/dist/quota/fileLock.js

@@ -1,64 +0,0 @@
-import { open, unlink, stat } from "node:fs/promises";
-const STALE_LOCK_MS = 30_000;
-const RETRY_INTERVAL_MS = 50;
-const DEFAULT_TIMEOUT_MS = 10_000;
-export class FileLockTimeoutError extends Error {
-    constructor(lockPath) {
-        super(`Timed out acquiring lock: ${lockPath}`);
-        this.name = "FileLockTimeoutError";
-    }
-}
-async function isLockStale(lockPath) {
-    try {
-        const info = await stat(lockPath);
-        return Date.now() - info.mtimeMs > STALE_LOCK_MS;
-    }
-    catch {
-        return false;
-    }
-}
-export async function acquireLock(lockPath, timeoutMs = DEFAULT_TIMEOUT_MS) {
-    const deadline = Date.now() + timeoutMs;
-    while (true) {
-        try {
-            const fd = await open(lockPath, "wx");
-            await fd.close();
-            return;
-        }
-        catch (err) {
-            if (err.code !== "EEXIST")
-                throw err;
-        }
-        if (await isLockStale(lockPath)) {
-            try {
-                await unlink(lockPath);
-                continue;
-            }
-            catch {
-                // Another process may have already cleaned it up
-            }
-        }
-        if (Date.now() >= deadline) {
-            throw new FileLockTimeoutError(lockPath);
-        }
-        await new Promise((r) => setTimeout(r, RETRY_INTERVAL_MS));
-    }
-}
-export async function releaseLock(lockPath) {
-    try {
-        await unlink(lockPath);
-    }
-    catch (err) {
-        if (err.code !== "ENOENT")
-            throw err;
-    }
-}
-export async function withFileLock(lockPath, fn, timeoutMs) {
-    await acquireLock(lockPath, timeoutMs);
-    try {
-        return await fn();
-    }
-    finally {
-        await releaseLock(lockPath);
-    }
-}

package/dist/quota/learnedQuotaSource.d.ts

@@ -1,7 +0,0 @@
-import type { QuotaSource, QuotaUsageSnapshot } from "./quotaSource.js";
-export declare class LearnedQuotaSource implements QuotaSource {
-    readonly name = "learned";
-    private halfLifeHours;
-    constructor(halfLifeHours?: number);
-    queryCurrentUsage(providerModelKey: string): Promise<QuotaUsageSnapshot | null>;
-}

package/dist/quota/learnedQuotaSource.js

@@ -1,25 +0,0 @@
-import { readQuotaState, computeMaxSafeConcurrency } from "./state.js";
-export class LearnedQuotaSource {
-    name = "learned";
-    halfLifeHours;
-    constructor(halfLifeHours = 24) {
-        this.halfLifeHours = halfLifeHours;
-    }
-    async queryCurrentUsage(providerModelKey) {
-        const state = await readQuotaState();
-        const entry = state.entries[providerModelKey];
-        if (!entry)
-            return null;
-        const maxSafe = computeMaxSafeConcurrency(entry, this.halfLifeHours);
-        const isInCooldown = entry.cooldown_until != null &&
-            new Date(entry.cooldown_until).getTime() > Date.now();
-        return {
-            remaining_pct: isInCooldown ? 0 : null,
-            reset_at: isInCooldown ? entry.cooldown_until : null,
-            requests_remaining: maxSafe,
-            tokens_remaining: null,
-            captured_at: entry.updated_at,
-            source: "learned",
-        };
-    }
-}

package/dist/quota/limits.d.ts

@@ -1,16 +0,0 @@
-import type { ResolvedProviderName, SessionConfig } from "../types/sessionConfig.js";
-import type { LimitConfidence, LimitSource, ResolvedLimits } from "./types.js";
-export type ProviderType = "hosted" | "local" | "unknown";
-export declare function classifyProvider(providerName: ResolvedProviderName): ProviderType;
-export declare function lookupKnownModel(modelKey: string): Pick<ResolvedLimits, "context_tokens" | "output_tokens"> | undefined;
-export interface LimitResolutionResult {
-    limits: ResolvedLimits;
-    source: LimitSource;
-    confidence: LimitConfidence;
-}
-export interface ResolveLimitsOptions {
-    providerName: ResolvedProviderName;
-    sessionConfig: SessionConfig;
-    hostModel?: string | null;
-}
-export declare function resolveLimits(options: ResolveLimitsOptions): LimitResolutionResult;

package/dist/quota/limits.js

@@ -1,77 +0,0 @@
-// RPM/TPM are omitted here — they are tier-dependent and must come from learning.
-const KNOWN_MODEL_LIMITS = {
-    "anthropic/claude-opus-4-7": { context_tokens: 200_000, output_tokens: 32_000 },
-    "anthropic/claude-sonnet-4-6": { context_tokens: 200_000, output_tokens: 8_192 },
-    "anthropic/claude-haiku-4-5": { context_tokens: 200_000, output_tokens: 8_192 },
-    "anthropic/claude-opus-4-5": { context_tokens: 200_000, output_tokens: 8_192 },
-    "anthropic/claude-sonnet-4-5": { context_tokens: 200_000, output_tokens: 8_192 },
-    "openai/gpt-4o": { context_tokens: 128_000, output_tokens: 16_384 },
-    "openai/gpt-4o-mini": { context_tokens: 128_000, output_tokens: 16_384 },
-    "google/gemini-2.0-flash": { context_tokens: 1_048_576, output_tokens: 8_192 },
-    "google/gemini-1.5-pro": { context_tokens: 2_097_152, output_tokens: 8_192 },
-};
-export function classifyProvider(providerName) {
-    switch (providerName) {
-        case "claude-code":
-            return "hosted";
-        case "opencode":
-        case "local-subprocess":
-            return "local";
-        case "subprocess-template":
-        case "vscode-task":
-        default:
-            return "unknown";
-    }
-}
-export function lookupKnownModel(modelKey) {
-    return KNOWN_MODEL_LIMITS[modelKey.toLowerCase().trim()];
-}
-function defaultLimits(sessionConfig) {
-    const quota = sessionConfig.quota ?? {};
-    return {
-        context_tokens: quota.default_context_tokens ?? 32_000,
-        output_tokens: quota.reserved_output_tokens ?? 4_096,
-        requests_per_minute: null,
-        input_tokens_per_minute: null,
-        output_tokens_per_minute: null,
-    };
-}
-export function resolveLimits(options) {
-    const { providerName: _providerName, sessionConfig, hostModel } = options;
-    const quota = sessionConfig.quota ?? {};
-    const defaults = defaultLimits(sessionConfig);
-    // 1. Explicit per-model config overrides
-    if (hostModel && quota.models?.[hostModel]) {
-        const override = quota.models[hostModel];
-        return {
-            limits: {
-                context_tokens: override.context_tokens ?? defaults.context_tokens,
-                output_tokens: override.output_tokens ?? defaults.output_tokens,
-                requests_per_minute: override.requests_per_minute ?? null,
-                input_tokens_per_minute: override.input_tokens_per_minute ?? null,
-                output_tokens_per_minute: override.output_tokens_per_minute ?? null,
-            },
-            source: "explicit_config",
-            confidence: "high",
-        };
-    }
-    // 2. Static known-model database (context/output only; RPM/TPM from learning)
-    if (hostModel) {
-        const known = lookupKnownModel(hostModel);
-        if (known) {
-            return {
-                limits: {
-                    context_tokens: known.context_tokens,
-                    output_tokens: known.output_tokens,
-                    requests_per_minute: null,
-                    input_tokens_per_minute: null,
-                    output_tokens_per_minute: null,
-                },
-                source: "known_metadata",
-                confidence: "medium",
-            };
-        }
-    }
-    // 3. Conservative defaults for all provider types
-    return { limits: defaults, source: "default", confidence: "low" };
-}

package/dist/quota/quotaSource.d.ts

@@ -1,12 +0,0 @@
-export interface QuotaUsageSnapshot {
-    remaining_pct: number | null;
-    reset_at: string | null;
-    requests_remaining: number | null;
-    tokens_remaining: number | null;
-    captured_at: string;
-    source: string;
-}
-export interface QuotaSource {
-    readonly name: string;
-    queryCurrentUsage(providerModelKey: string): Promise<QuotaUsageSnapshot | null>;
-}

package/dist/quota/slidingWindow.d.ts

@@ -1,4 +0,0 @@
-export interface SlidingWindowResult<T> {
-    results: PromiseSettledResult<T>[];
-}
-export declare function runSlidingWindow<T>(tasks: Array<() => Promise<T>>, concurrency: number, onComplete?: (index: number, result: PromiseSettledResult<T>) => void): Promise<SlidingWindowResult<T>>;

package/dist/quota/slidingWindow.js

@@ -1,28 +0,0 @@
-export async function runSlidingWindow(tasks, concurrency, onComplete) {
-    const results = new Array(tasks.length);
-    let nextIndex = 0;
-    async function runOne(index) {
-        let result;
-        try {
-            const value = await tasks[index]();
-            result = { status: "fulfilled", value };
-        }
-        catch (reason) {
-            result = { status: "rejected", reason };
-        }
-        results[index] = result;
-        onComplete?.(index, result);
-        if (nextIndex < tasks.length) {
-            const next = nextIndex++;
-            await runOne(next);
-        }
-    }
-    const initialBatch = Math.min(concurrency, tasks.length);
-    const runners = [];
-    for (let i = 0; i < initialBatch; i++) {
-        const idx = nextIndex++;
-        runners.push(runOne(idx));
-    }
-    await Promise.all(runners);
-    return { results };
-}

package/dist/quota/state.d.ts

@@ -1,15 +0,0 @@
-import type { ObservedWaveOutcome, QuotaState, QuotaStateEntry } from "./types.js";
-export declare function getQuotaStatePath(): string;
-export declare function decayWeight(weight: number, elapsedHours: number, halfLifeHours: number): number;
-export declare function applyDecayToEntry(entry: QuotaStateEntry, halfLifeHours: number): QuotaStateEntry;
-export declare function readQuotaState(): Promise<QuotaState>;
-export declare function writeQuotaState(state: QuotaState): Promise<void>;
-/**
- * Returns the highest concurrency level for which decayed success evidence
- * exceeds failure evidence, with a minimum of 1.
- */
-export declare function computeMaxSafeConcurrency(entry: QuotaStateEntry, halfLifeHours: number, maxToCheck?: number): number;
-export declare function computeRampUpConcurrency(entry: QuotaStateEntry, halfLifeHours: number, maxToCheck?: number): number;
-export declare function computeBackoffCooldownMs(consecutive429Count: number): number;
-export declare function computeBackoffFailureWeight(consecutive429Count: number): number;
-export declare function recordWaveOutcome(providerModelKey: string, outcome: ObservedWaveOutcome, halfLifeHours: number): Promise<void>;