@poetic-ai/poetic 1.42.0

package/dist/chunk-WX5IRLF6.js

@@ -0,0 +1,740 @@
+import {
+  appendObservation,
+  applyWeight,
+  createFinding,
+  createObservation,
+  exceedsBatchBudget,
+  findDuplicate,
+  generateFingerprint,
+  loadIssuePolicy,
+  normalizePath,
+  readFinding,
+  trackOccurrence,
+  updateFinding
+} from "./chunk-BZU2O43F.js";
+import {
+  withIngestLock
+} from "./chunk-MQ4WA34C.js";
+import {
+  createWorkItemFile
+} from "./chunk-6MFRHTRI.js";
+import {
+  withDeferredIndexRegeneration,
+  withIndexRegeneration
+} from "./chunk-OPYFYTWQ.js";
+import {
+  getBucketPathByKind
+} from "./chunk-HOYBYAOA.js";
+import {
+  listMarkdownFiles,
+  parseMarkdownFile,
+  writeMarkdownFile
+} from "./chunk-OIS7J26S.js";
+import {
+  emitCustomWarning,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/planning/agent-ingest.ts
+import { z } from "zod";
+
+// src/planning/ingest-pipeline.ts
+import * as path2 from "path";
+
+// src/planning/sarif-ingest.ts
+function parseSarif(jsonString) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonString);
+  } catch (e) {
+    throw new Error(`Invalid SARIF JSON: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("SARIF must be a JSON object");
+  }
+  const log = parsed;
+  if (!log.version || typeof log.version !== "string") {
+    throw new Error("SARIF must have a version field");
+  }
+  if (!Array.isArray(log.runs)) {
+    throw new Error("SARIF must have a runs array");
+  }
+  return parsed;
+}
+function convertSarifToFindings(sarif, options = {}) {
+  const findings = [];
+  for (const run of sarif.runs) {
+    const rulesById = buildRuleMap(run.tool.driver.rules ?? []);
+    const provenance = buildProvenance(run, options);
+    for (const result of run.results ?? []) {
+      const finding = convertResult(result, rulesById, provenance, options);
+      if (finding) {
+        findings.push(finding);
+      }
+    }
+  }
+  return findings;
+}
+function convertResult(result, rulesById, provenance, options) {
+  const ruleId = result.ruleId ?? "unknown";
+  const rule = rulesById.get(ruleId);
+  const title = rule?.shortDescription?.text ?? result.message.text;
+  const body = rule?.fullDescription?.text ?? result.message.text;
+  const category = inferCategory(ruleId, rule, options);
+  const level = result.level ?? rule?.defaultConfiguration?.level ?? "warning";
+  const severity = mapSarifLevel(level);
+  const codeLocations = (result.locations ?? []).map(convertLocation).filter(Boolean);
+  const primaryLocation = result.locations?.[0];
+  const filePath = extractFilePath(primaryLocation) ?? "unknown";
+  const snippet = extractSnippet(primaryLocation) ?? title;
+  const symbolName = extractSymbolName(primaryLocation);
+  const fingerprint = {
+    ruleId,
+    snippet,
+    symbolName,
+    path: filePath
+  };
+  return {
+    title: title.slice(0, 200),
+    // Truncate overly long titles
+    category,
+    severity,
+    reporterConfidence: options.reporterConfidence ?? 0.5,
+    reportedBy: provenance,
+    codeLocations,
+    fingerprint,
+    body: body !== title ? body : void 0,
+    detectionRunId: options.detectionRunId
+  };
+}
+function buildRuleMap(rules) {
+  const map = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    map.set(rule.id, rule);
+  }
+  return map;
+}
+function buildProvenance(run, options) {
+  return {
+    harness: options.harness ?? "system",
+    provider: options.provider ?? run.tool.driver.name,
+    model: run.tool.driver.name,
+    modelVersion: run.tool.driver.version
+  };
+}
+function inferCategory(ruleId, rule, options) {
+  if (options.categoryMap?.[ruleId]) {
+    return options.categoryMap[ruleId];
+  }
+  const tags = rule?.properties?.tags;
+  if (tags) {
+    if (tags.some((t) => /security|vuln|cwe/i.test(t))) return "security";
+    if (tags.some((t) => /performance|perf/i.test(t))) return "performance";
+    if (tags.some((t) => /correct|logic|bug/i.test(t))) return "correctness";
+    if (tags.some((t) => /style|format/i.test(t))) return "style";
+  }
+  if (/security|vuln|inject|xss|csrf|sqli/i.test(ruleId)) return "security";
+  if (/perf|performance|slow|memory|leak/i.test(ruleId)) return "performance";
+  if (/style|format|indent|naming/i.test(ruleId)) return "style";
+  return options.defaultCategory ?? "bug";
+}
+function mapSarifLevel(level) {
+  switch (level) {
+    case "error":
+      return "high";
+    case "warning":
+      return "medium";
+    case "note":
+      return "low";
+    case "none":
+      return void 0;
+  }
+}
+function convertLocation(location) {
+  const physical = location.physicalLocation;
+  if (!physical?.artifactLocation?.uri) return null;
+  const file = physical.artifactLocation.uri.replace(/^file:\/\//, "");
+  const region = physical.region;
+  const lines = region?.startLine && region?.endLine ? [region.startLine, region.endLine] : region?.startLine ? [region.startLine, region.startLine] : void 0;
+  const symbolName = location.logicalLocations?.[0]?.name;
+  return {
+    file,
+    lines,
+    snippet: region?.snippet?.text,
+    symbolName
+  };
+}
+function extractFilePath(location) {
+  return location?.physicalLocation?.artifactLocation?.uri?.replace(/^file:\/\//, "");
+}
+function extractSnippet(location) {
+  return location?.physicalLocation?.region?.snippet?.text;
+}
+function extractSymbolName(location) {
+  return location?.logicalLocations?.[0]?.name;
+}
+
+// src/planning/suppression-manager.ts
+import * as path from "path";
+var warnedMalformedSuppressionFiles = /* @__PURE__ */ new Set();
+async function createSuppression(repoRoot, options) {
+  if (!options.ruleId && !options.pathGlob) {
+    throw new Error("Suppression must specify at least one of ruleId or pathGlob");
+  }
+  return withIndexRegeneration(repoRoot, async () => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const meta = {
+      kind: "suppression",
+      ruleId: options.ruleId,
+      pathGlob: options.pathGlob,
+      reason: options.reason,
+      createdBy: options.createdBy,
+      createdAt: now,
+      expiresAt: options.expiresAt
+    };
+    const result = await createWorkItemFile({
+      repoRoot,
+      bucket: "suppression",
+      title: formatSuppressionTitle(options),
+      description: options.body?.trim() || "",
+      metadata: stripUndefined(meta)
+    });
+    const suppression = { ...meta, id: result.id };
+    return {
+      id: result.id,
+      filePath: result.path,
+      suppression
+    };
+  });
+}
+async function readSuppression(repoRoot, suppressionId) {
+  const dir = getBucketPathByKind("suppression", repoRoot);
+  const filePath = path.join(dir, `${suppressionId}.md`);
+  let suppression;
+  let body;
+  try {
+    ({ yaml: suppression, body } = await parseMarkdownFile(filePath));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Suppression not found: ${suppressionId}`);
+    }
+    throw error;
+  }
+  return { suppression, body, filePath };
+}
+async function listSuppressions(repoRoot, activeOnly = false) {
+  const dir = getBucketPathByKind("suppression", repoRoot);
+  const files = await listMarkdownFiles(dir);
+  const results = [];
+  const now = /* @__PURE__ */ new Date();
+  for (const file of files) {
+    try {
+      const { yaml: suppression } = await parseMarkdownFile(file);
+      if (activeOnly && suppression.expiresAt && new Date(suppression.expiresAt) <= now) {
+        continue;
+      }
+      results.push(suppression);
+    } catch (error) {
+      const relativePath = path.relative(repoRoot, file);
+      if (!warnedMalformedSuppressionFiles.has(relativePath)) {
+        warnedMalformedSuppressionFiles.add(relativePath);
+        emitWarning(
+          "CFG-002",
+          {
+            taskId: "suppression-manager",
+            subsystem: "planning",
+            executionPhase: "execution"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              operation: "parse-suppression",
+              file: relativePath,
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }
+        );
+      }
+    }
+  }
+  return results;
+}
+async function auditMalformedSuppressionFiles(repoRoot) {
+  const dir = getBucketPathByKind("suppression", repoRoot);
+  const files = await listMarkdownFiles(dir);
+  const results = [];
+  for (const file of files) {
+    try {
+      await parseMarkdownFile(file);
+    } catch (error) {
+      results.push({
+        bucket: "suppression",
+        filePath: path.relative(repoRoot, file),
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+async function expireSuppression(repoRoot, suppressionId) {
+  return withIndexRegeneration(repoRoot, async () => {
+    const { suppression, body, filePath } = await readSuppression(repoRoot, suppressionId);
+    const updated = {
+      ...suppression,
+      expiresAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeMarkdownFile(filePath, stripUndefined(updated), body);
+    return updated;
+  });
+}
+async function getActiveSuppressions(repoRoot) {
+  return listSuppressions(repoRoot, true);
+}
+function formatSuppressionTitle(options) {
+  const parts = ["Suppress"];
+  if (options.ruleId) parts.push(`rule:${options.ruleId}`);
+  if (options.pathGlob) parts.push(`path:${options.pathGlob}`);
+  return parts.join(" ");
+}
+function stripUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/planning/ingest-pipeline.ts
+function emitIngestPipelineWarning(message, metadata) {
+  emitCustomWarning(
+    "WARN" /* WARN */,
+    "validation" /* VALIDATION */,
+    message,
+    {
+      taskId: "ingest-pipeline",
+      subsystem: "planning/ingest-pipeline",
+      executionPhase: "execution"
+    },
+    { metadata, skipConsole: true }
+  );
+}
+async function loadFingerprintIndex(repoRoot) {
+  const findingDir = getBucketPathByKind("finding", repoRoot);
+  let files;
+  try {
+    files = await listMarkdownFiles(findingDir);
+  } catch {
+    return { entries: [], warnings: [] };
+  }
+  const entries = [];
+  const warnings = [];
+  for (const file of files) {
+    try {
+      const { yaml: finding } = await parseMarkdownFile(file);
+      if (finding.fingerprint) {
+        entries.push({
+          findingId: finding.id,
+          fingerprint: finding.fingerprint
+        });
+      }
+    } catch {
+      const relativePath = path2.relative(repoRoot, file);
+      const warning = `Skipped malformed fingerprint index file: ${relativePath}`;
+      warnings.push(warning);
+      emitIngestPipelineWarning(warning, {
+        file: relativePath,
+        operation: "load-fingerprint-index"
+      });
+    }
+  }
+  return {
+    entries: entries.sort((a, b) => a.findingId.localeCompare(b.findingId)),
+    warnings
+  };
+}
+async function ingestFindings(repoRoot, candidates, options = {}) {
+  const effectiveRoot = options.planningRoot ?? repoRoot;
+  return withIngestLock(
+    effectiveRoot,
+    () => withDeferredIndexRegeneration(effectiveRoot, async () => {
+      const policy = options.policy ?? loadIssuePolicy(effectiveRoot);
+      if (exceedsBatchBudget(candidates.length, policy)) {
+        throw new Error(
+          `Ingest batch exceeds policy budget: ${candidates.length} > ${policy.ingest.maxFindingsPerBatch}`
+        );
+      }
+      const suppressions = await getActiveSuppressions(effectiveRoot);
+      const fingerprintIndex = await loadFingerprintIndex(effectiveRoot);
+      const existingFingerprints = fingerprintIndex.entries;
+      const summary = {
+        total: candidates.length,
+        created: 0,
+        recurrenceCreated: 0,
+        dedupedExact: 0,
+        dedupedFuzzy: 0,
+        suppressed: 0,
+        warnings: [...fingerprintIndex.warnings],
+        errors: [],
+        findings: []
+      };
+      for (let i = 0; i < candidates.length; i++) {
+        const candidate = candidates[i];
+        const weightedCandidate = {
+          ...candidate,
+          reporterConfidence: applyWeight(
+            candidate.reporterConfidence,
+            candidate.reportedBy.provider,
+            policy
+          )
+        };
+        try {
+          const result = await ingestSingleFinding(
+            effectiveRoot,
+            weightedCandidate,
+            suppressions,
+            existingFingerprints,
+            policy
+          );
+          summary.findings.push(result);
+          switch (result.action) {
+            case "created":
+              summary.created++;
+              existingFingerprints.push({
+                findingId: result.id,
+                fingerprint: generateFingerprint(weightedCandidate.fingerprint)
+              });
+              break;
+            case "created_recurrence":
+              summary.created++;
+              summary.recurrenceCreated++;
+              existingFingerprints.push({
+                findingId: result.id,
+                fingerprint: generateFingerprint(weightedCandidate.fingerprint)
+              });
+              break;
+            case "created_possible_duplicate":
+              summary.created++;
+              summary.dedupedFuzzy++;
+              existingFingerprints.push({
+                findingId: result.id,
+                fingerprint: generateFingerprint(weightedCandidate.fingerprint)
+              });
+              break;
+            case "occurrence_bumped":
+              summary.dedupedExact++;
+              break;
+            case "marked_duplicate":
+              summary.dedupedFuzzy++;
+              break;
+            case "suppressed":
+              summary.suppressed++;
+              break;
+          }
+        } catch (error) {
+          summary.errors.push({
+            index: i,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      return summary;
+    })
+  );
+}
+async function ingestSingleFinding(repoRoot, candidate, suppressions, existingFingerprints, policy) {
+  const fp = generateFingerprint(candidate.fingerprint);
+  const dedupMatch = findDuplicate(fp, existingFingerprints);
+  if (dedupMatch) {
+    if (dedupMatch.strength === "exact") {
+      const exactLifecycleMatch = await selectExactLifecycleMatch(
+        repoRoot,
+        fp,
+        existingFingerprints,
+        dedupMatch.existingFindingId
+      );
+      const { finding, recurrenceDecision } = exactLifecycleMatch;
+      if (recurrenceDecision.createRecurrence) {
+        const result2 = await createFinding(repoRoot, {
+          ...candidate,
+          suppressions
+        });
+        if (!result2.suppressed) {
+          await updateFinding(repoRoot, result2.id, result2.finding.version, {
+            recurrenceOfFindingId: finding.id,
+            recurrenceOfStatus: finding.status,
+            recurrenceOfIssueId: recurrenceDecision.relatedIssueId,
+            requiresHumanReview: true
+          });
+        }
+        return {
+          id: result2.id,
+          action: result2.suppressed ? "suppressed" : "created_recurrence",
+          title: candidate.title
+        };
+      }
+      const occurrence = trackOccurrence(finding.occurrenceCount);
+      const observation = createObservation(
+        candidate.reportedBy,
+        candidate.reporterConfidence,
+        candidate.severity,
+        candidate.codeLocations
+      );
+      const observedFinding = appendObservation({
+        finding,
+        observation,
+        expectedVersion: finding.version
+      });
+      const reviewThreshold = policy.ingest.maxOccurrencesBeforeReview;
+      await updateFinding(repoRoot, exactLifecycleMatch.findingId, finding.version, {
+        observations: observedFinding.observations,
+        lastSeenAt: occurrence.lastSeenAt,
+        occurrenceCount: occurrence.occurrenceCount,
+        requiresHumanReview: reviewThreshold > 0 && occurrence.occurrenceCount >= reviewThreshold ? true : finding.requiresHumanReview
+      });
+      return {
+        id: exactLifecycleMatch.findingId,
+        action: "occurrence_bumped",
+        title: candidate.title
+      };
+    }
+    if (dedupMatch.strength === "fuzzy") {
+      const result2 = await createFinding(repoRoot, {
+        ...candidate,
+        suppressions
+      });
+      if (!result2.suppressed) {
+        await updateFinding(repoRoot, result2.id, result2.finding.version, {
+          possibleDuplicateOfFindingId: dedupMatch.existingFindingId,
+          possibleDuplicateConfidence: dedupMatch.confidence,
+          possibleDuplicateReason: dedupMatch.reason,
+          requiresHumanReview: true
+        });
+      }
+      return {
+        id: result2.id,
+        action: result2.suppressed ? "suppressed" : "created_possible_duplicate",
+        title: candidate.title
+      };
+    }
+  }
+  const result = await createFinding(repoRoot, {
+    ...candidate,
+    suppressions
+  });
+  return {
+    id: result.id,
+    action: result.suppressed ? "suppressed" : "created",
+    title: candidate.title
+  };
+}
+async function selectExactLifecycleMatch(repoRoot, candidateFingerprint, existingFingerprints, fallbackFindingId) {
+  const exactMatchIds = [
+    ...new Set(
+      existingFingerprints.filter((entry) => entry.fingerprint.compositeHash === candidateFingerprint.compositeHash).map((entry) => entry.findingId)
+    )
+  ].sort((a, b) => a.localeCompare(b));
+  const candidateIds = exactMatchIds.length > 0 ? exactMatchIds : [fallbackFindingId];
+  let terminalFallback = null;
+  for (const findingId of candidateIds) {
+    try {
+      const { finding: finding2 } = await readFinding(repoRoot, findingId);
+      const recurrenceDecision = await decideRecurrence(repoRoot, finding2);
+      const match = {
+        findingId,
+        finding: finding2,
+        recurrenceDecision
+      };
+      if (!recurrenceDecision.createRecurrence) {
+        return match;
+      }
+      if (!terminalFallback) {
+        terminalFallback = match;
+      }
+    } catch {
+    }
+  }
+  if (terminalFallback) {
+    return terminalFallback;
+  }
+  const { finding } = await readFinding(repoRoot, fallbackFindingId);
+  return {
+    findingId: fallbackFindingId,
+    finding,
+    recurrenceDecision: await decideRecurrence(repoRoot, finding)
+  };
+}
+async function decideRecurrence(_repoRoot, finding) {
+  switch (finding.status) {
+    case "raw":
+    case "open":
+      return { createRecurrence: false };
+    case "closed":
+      return { createRecurrence: true };
+    default:
+      return { createRecurrence: false };
+  }
+}
+async function ingestSarif(repoRoot, sarifContent, options = {}) {
+  const { policy, planningRoot, ...conversionOptions } = options;
+  const sarif = parseSarif(sarifContent);
+  const converted = convertSarifToFindings(sarif, conversionOptions);
+  const candidates = converted.map((c) => ({
+    title: c.title,
+    category: c.category,
+    severity: c.severity,
+    reportedBy: c.reportedBy,
+    reporterConfidence: c.reporterConfidence,
+    codeLocations: c.codeLocations,
+    fingerprint: c.fingerprint,
+    body: c.body,
+    detectionRunId: c.detectionRunId
+  }));
+  return ingestFindings(repoRoot, candidates, { policy, planningRoot: options.planningRoot });
+}
+
+// src/planning/agent-ingest.ts
+var AgentOutputParseError = class extends Error {
+  constructor(message, rawOutput) {
+    super(message);
+    this.rawOutput = rawOutput;
+    this.name = "AgentOutputParseError";
+  }
+  rawOutput;
+};
+function optionalNullable(schema) {
+  return z.preprocess((value) => value === null ? void 0 : value, schema.optional());
+}
+var agentFindingSchema = z.object({
+  title: z.string().min(1),
+  category: z.enum(["bug", "performance", "security", "correctness", "style"]),
+  severity: optionalNullable(z.enum(["critical", "high", "medium", "low"])),
+  confidence: z.number().min(0).max(1),
+  ruleId: z.string().min(1),
+  file: z.string().min(1),
+  startLine: optionalNullable(z.number().int().positive()),
+  endLine: optionalNullable(z.number().int().positive()),
+  snippet: optionalNullable(z.string()),
+  symbolName: optionalNullable(z.string()),
+  reasoning: z.string().min(1)
+});
+var agentOutputSchema = z.object({
+  findings: z.array(agentFindingSchema)
+});
+var delegationMetadataSchema = z.object({
+  requestedSubagents: z.number().int().positive(),
+  requestedWaves: z.number().int().positive(),
+  launched: optionalNullable(z.number().int().nonnegative()),
+  completed: optionalNullable(z.number().int().nonnegative()),
+  failed: optionalNullable(z.number().int().nonnegative()),
+  partial: optionalNullable(z.boolean())
+});
+var delegatedAgentOutputSchema = z.object({
+  findings: z.array(agentFindingSchema),
+  delegation: delegationMetadataSchema.optional()
+});
+function extractJsonBlocks(raw) {
+  return Array.from(raw.matchAll(/```json\b\s*([\s\S]*?)```/gi));
+}
+function extractValidJsonBlock(raw, schema, strategy) {
+  const jsonBlocks = extractJsonBlocks(raw);
+  if (jsonBlocks.length === 0) {
+    throw new AgentOutputParseError(
+      "No ```json code block found in agent output. Agent must return findings in a ```json block.",
+      raw
+    );
+  }
+  const orderedBlocks = strategy === "last_valid" ? [...jsonBlocks].reverse() : jsonBlocks;
+  const errors = [];
+  for (const [index, block] of orderedBlocks.entries()) {
+    const originalIndex = strategy === "last_valid" ? jsonBlocks.length - 1 - index : index;
+    const jsonString = block[1]?.trim() ?? "";
+    let parsed;
+    try {
+      parsed = JSON.parse(jsonString);
+    } catch (e) {
+      errors.push(
+        `block ${originalIndex + 1}: invalid JSON (${e instanceof Error ? e.message : String(e)})`
+      );
+      continue;
+    }
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+      const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      errors.push(`block ${originalIndex + 1}: schema validation failed (${issues})`);
+      continue;
+    }
+    return result.data;
+  }
+  throw new AgentOutputParseError(
+    `Failed to parse/validate ${jsonBlocks.length} JSON block(s): ${errors.join("; ")}`,
+    raw
+  );
+}
+function parseAgentOutput(raw) {
+  const result = extractValidJsonBlock(raw, agentOutputSchema, "first_valid");
+  return result.findings;
+}
+function parseDelegatedAgentOutput(raw) {
+  return extractValidJsonBlock(raw, delegatedAgentOutputSchema, "last_valid");
+}
+function convertAgentFindings(findings, options = {}) {
+  const provenance = {
+    harness: options.harness ?? "system",
+    provider: options.provider ?? "unknown",
+    model: options.model ?? "unknown",
+    modelVersion: options.modelVersion
+  };
+  const minConfidence = options.minConfidence ?? 0;
+  return findings.filter((f) => f.confidence >= minConfidence).map((f) => convertSingleFinding(f, provenance));
+}
+function convertSingleFinding(finding, provenance) {
+  const normalizedFile = normalizePath(finding.file);
+  const lines = finding.startLine && finding.endLine ? [finding.startLine, finding.endLine] : finding.startLine ? [finding.startLine, finding.startLine] : void 0;
+  const codeLocation = {
+    file: normalizedFile,
+    lines,
+    snippet: finding.snippet ?? void 0,
+    symbolName: finding.symbolName ?? void 0
+  };
+  const fingerprint = {
+    ruleId: finding.ruleId,
+    snippet: finding.snippet ?? finding.title,
+    symbolName: finding.symbolName ?? void 0,
+    path: normalizedFile
+  };
+  return {
+    title: finding.title.slice(0, 200),
+    category: finding.category,
+    severity: finding.severity ?? void 0,
+    reportedBy: provenance,
+    reporterConfidence: finding.confidence,
+    codeLocations: [codeLocation],
+    fingerprint,
+    body: finding.reasoning
+  };
+}
+async function ingestAgentOutput(repoRoot, raw, options = {}) {
+  const { policy, planningRoot, ...agentOptions } = options;
+  const findings = parseAgentOutput(raw);
+  const candidates = convertAgentFindings(findings, agentOptions);
+  return ingestFindings(repoRoot, candidates, { policy, planningRoot });
+}
+
+export {
+  createSuppression,
+  listSuppressions,
+  auditMalformedSuppressionFiles,
+  expireSuppression,
+  ingestFindings,
+  ingestSarif,
+  AgentOutputParseError,
+  agentFindingSchema,
+  agentOutputSchema,
+  parseAgentOutput,
+  parseDelegatedAgentOutput,
+  convertAgentFindings,
+  ingestAgentOutput
+};
+//# sourceMappingURL=chunk-WX5IRLF6.js.map