context-armor 0.1.0

package/src/cli.js

@@ -0,0 +1,290 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { parseSize } from "./config.js";
+import { protectedPathsFromFindings, writeProtectionPolicies } from "./policy.js";
+import { formatJson, formatPretty, formatSarif } from "./reporters.js";
+import { scan, summarize } from "./scanner.js";
+import { severityRank } from "./rules.js";
+
+const packageJson = JSON.parse(
+  await fs.readFile(new URL("../package.json", import.meta.url), "utf8"),
+);
+
+const HELP = `Context Armor ${packageJson.version}
+Local-first preflight scanning before AI agents read your workspace.
+
+Usage:
+  context-armor scan [path] [options]
+  context-armor protect [path] [options]
+  context-armor init [path]
+  context-armor doctor
+
+Scan options:
+  --format <pretty|json|sarif>  Output format (default: pretty)
+  --output <file>               Write the report to a file
+  --fail-on <level|none>        Exit 1 at critical, high, medium, or low
+  --max-file-size <size>        Per-file limit, e.g. 8mb
+  --max-files <count>           Stop after this many discovered files
+  --config <file>               Use an explicit JSON config
+  --baseline <file>             Suppress matching fingerprints
+  --write-baseline <file>       Save current fingerprints as a baseline
+  --ocr                         Scan images with local Tesseract
+  --ocr-languages <value>       Tesseract languages (default: eng+kor)
+  --no-documents                Do not extract Office/PDF documents
+  --no-gitignore                Do not respect .gitignore
+  --no-hidden                   Skip hidden files
+  --no-color                    Disable ANSI colors
+  --quiet                       Print only errors
+  -h, --help                    Show help
+  -v, --version                 Show version
+
+Examples:
+  npx context-armor scan .
+  npx context-armor scan . --format sarif --output results.sarif
+  npx context-armor protect . --fail-on critical
+`;
+
+function readValue(args, index, flag) {
+  if (index + 1 >= args.length) throw new Error(`${flag} requires a value`);
+  return args[index + 1];
+}
+
+function parseArgs(args) {
+  const parsed = {
+    command: "scan",
+    target: ".",
+    format: "pretty",
+    color: undefined,
+  };
+  let index = 0;
+  if (args[index] && !args[index].startsWith("-")) {
+    parsed.command = args[index];
+    index += 1;
+  }
+  if (["scan", "protect", "init"].includes(parsed.command) && args[index] && !args[index].startsWith("-")) {
+    parsed.target = args[index];
+    index += 1;
+  }
+
+  while (index < args.length) {
+    const flag = args[index];
+    if (flag === "-h" || flag === "--help") parsed.help = true;
+    else if (flag === "-v" || flag === "--version") parsed.version = true;
+    else if (flag === "--ocr") parsed.ocr = true;
+    else if (flag === "--no-documents") parsed.documents = false;
+    else if (flag === "--no-gitignore") parsed.respectGitignore = false;
+    else if (flag === "--no-hidden") parsed.includeHidden = false;
+    else if (flag === "--no-color") parsed.color = false;
+    else if (flag === "--quiet") parsed.quiet = true;
+    else if (flag === "--format") {
+      parsed.format = readValue(args, index, flag);
+      index += 1;
+    } else if (flag === "--output") {
+      parsed.output = readValue(args, index, flag);
+      index += 1;
+    } else if (flag === "--fail-on") {
+      parsed.failOn = readValue(args, index, flag);
+      index += 1;
+    } else if (flag === "--max-file-size") {
+      parsed.maxFileSize = parseSize(readValue(args, index, flag));
+      index += 1;
+    } else if (flag === "--max-files") {
+      parsed.maxFiles = Number(readValue(args, index, flag));
+      index += 1;
+    } else if (flag === "--config") {
+      parsed.configPath = readValue(args, index, flag);
+      index += 1;
+    } else if (flag === "--baseline") {
+      parsed.baseline = readValue(args, index, flag);
+      index += 1;
+    } else if (flag === "--write-baseline") {
+      parsed.writeBaseline = readValue(args, index, flag);
+      index += 1;
+    } else if (flag === "--ocr-languages") {
+      parsed.ocrLanguages = readValue(args, index, flag);
+      index += 1;
+    } else {
+      throw new Error(`Unknown option: ${flag}`);
+    }
+    index += 1;
+  }
+  return parsed;
+}
+
+async function loadBaseline(file) {
+  if (!file) return new Set();
+  const value = JSON.parse(await fs.readFile(path.resolve(file), "utf8"));
+  const fingerprints = Array.isArray(value) ? value : value.fingerprints;
+  if (!Array.isArray(fingerprints)) throw new Error(`Invalid baseline file: ${file}`);
+  return new Set(fingerprints);
+}
+
+async function applyBaseline(result, baselineFile) {
+  const fingerprints = await loadBaseline(baselineFile);
+  if (!fingerprints.size) return result;
+  const original = result.findings.length;
+  result.findings = result.findings.filter(
+    (finding) => !fingerprints.has(finding.fingerprint),
+  );
+  result.suppressed = original - result.findings.length;
+  result.summary = summarize(result.findings);
+  return result;
+}
+
+async function writeBaseline(file, result) {
+  const value = {
+    schemaVersion: "1.0",
+    generatedAt: new Date().toISOString(),
+    fingerprints: result.findings.map((finding) => finding.fingerprint).sort(),
+  };
+  await fs.writeFile(path.resolve(file), `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function shouldFail(result, failOn) {
+  if (!failOn || failOn === "none") return false;
+  if (!(failOn in severityRank)) throw new Error(`Invalid --fail-on level: ${failOn}`);
+  return result.findings.some(
+    (finding) => severityRank[finding.severity] <= severityRank[failOn],
+  );
+}
+
+async function initProject(target) {
+  const root = path.resolve(target);
+  await fs.mkdir(root, { recursive: true });
+  const files = {
+    "context-armor.config.json": `${JSON.stringify(
+      {
+        failOn: "high",
+        maxFileSize: "8mb",
+        documents: true,
+        ocr: false,
+        respectGitignore: true,
+        ignore: ["fixtures/public/**"],
+        disabledRules: [],
+        severity: {},
+      },
+      null,
+      2,
+    )}\n`,
+    ".contextarmorignore":
+      "# Context Armor-only exclusions\n# Add generated fixtures or intentionally public data here.\n",
+    ".github/workflows/context-armor.yml": `name: Context Armor
+on:
+  pull_request:
+  push:
+    branches: [main]
+permissions:
+  contents: read
+  security-events: write
+jobs:
+  scan:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: feelyday/context-armor@v0
+        with:
+          path: .
+          fail_on: high
+          output: context-armor-results.sarif
+      - uses: github/codeql-action/upload-sarif@v3
+        if: always()
+        with:
+          sarif_file: context-armor-results.sarif
+`,
+  };
+  const created = [];
+  for (const [relative, contents] of Object.entries(files)) {
+    const file = path.join(root, relative);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    try {
+      await fs.writeFile(file, contents, { encoding: "utf8", flag: "wx" });
+      created.push(relative);
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+    }
+  }
+  return created;
+}
+
+function commandAvailable(command, args = ["--version"]) {
+  const result = spawnSync(command, args, { encoding: "utf8", timeout: 5_000 });
+  return {
+    available: !result.error && result.status === 0,
+    version: (result.stdout || result.stderr || "").trim().split("\n")[0],
+  };
+}
+
+function formatResult(result, format, color) {
+  if (format === "pretty") return formatPretty(result, { color });
+  if (format === "json") return formatJson(result);
+  if (format === "sarif") return formatSarif(result);
+  throw new Error(`Unknown format: ${format}`);
+}
+
+export async function runCli(args) {
+  const parsed = parseArgs(args);
+  if (parsed.version) {
+    process.stdout.write(`${packageJson.version}\n`);
+    return;
+  }
+  if (parsed.help || parsed.command === "help") {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (parsed.command === "doctor") {
+    const checks = [
+      ["Node.js", { available: Number(process.versions.node.split(".")[0]) >= 20, version: process.version }],
+      ["pdftotext", commandAvailable("pdftotext")],
+      ["Tesseract (optional)", commandAvailable("tesseract")],
+      ["Git", commandAvailable("git")],
+    ];
+    for (const [name, result] of checks) {
+      process.stdout.write(`${result.available ? "✓" : "○"} ${name}${result.version ? ` — ${result.version}` : ""}\n`);
+    }
+    return;
+  }
+  if (parsed.command === "init") {
+    const created = await initProject(parsed.target);
+    process.stdout.write(
+      created.length
+        ? `Created ${created.join(", ")}\n`
+        : "Context Armor is already initialized; no files changed.\n",
+    );
+    return;
+  }
+  if (!["scan", "protect"].includes(parsed.command)) {
+    throw new Error(`Unknown command: ${parsed.command}`);
+  }
+
+  let result = await scan(parsed.target, {
+    configPath: parsed.configPath,
+    failOn: parsed.failOn,
+    maxFileSize: parsed.maxFileSize,
+    maxFiles: parsed.maxFiles,
+    ocr: parsed.ocr,
+    ocrLanguages: parsed.ocrLanguages,
+    documents: parsed.documents,
+    respectGitignore: parsed.respectGitignore,
+    includeHidden: parsed.includeHidden,
+    toolVersion: packageJson.version,
+  });
+  result = await applyBaseline(result, parsed.baseline);
+  if (parsed.writeBaseline) await writeBaseline(parsed.writeBaseline, result);
+
+  if (parsed.command === "protect") {
+    const paths = protectedPathsFromFindings(result.findings, parsed.failOn || "high");
+    const files = await writeProtectionPolicies(path.resolve(parsed.target), paths);
+    result.protection = { paths: paths.length, files };
+  }
+
+  const output = formatResult(result, parsed.format, parsed.color);
+  if (parsed.output) await fs.writeFile(path.resolve(parsed.output), output, "utf8");
+  else if (!parsed.quiet) process.stdout.write(output);
+
+  const effectiveFailOn = parsed.failOn || result.policy?.failOn || "high";
+  if (shouldFail(result, effectiveFailOn)) process.exitCode = 1;
+}
+
+export { applyBaseline, initProject, parseArgs, shouldFail };

package/src/config.js

@@ -0,0 +1,78 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export const defaultConfig = Object.freeze({
+  failOn: "high",
+  maxFileSize: 8 * 1024 * 1024,
+  maxFiles: 100_000,
+  documents: true,
+  ocr: false,
+  respectGitignore: true,
+  includeHidden: true,
+  ignore: [
+    "**/.git/**",
+    "**/node_modules/**",
+    "**/vendor/**",
+    "**/.next/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/.context-armor/**",
+  ],
+  disabledRules: [],
+  severity: {},
+});
+
+function parseSize(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  const match = String(value).trim().match(/^(\d+(?:\.\d+)?)\s*(b|kb|kib|mb|mib|gb|gib)?$/i);
+  if (!match) throw new Error(`Invalid size: ${value}`);
+  const units = {
+    b: 1,
+    kb: 1000,
+    kib: 1024,
+    mb: 1000 ** 2,
+    mib: 1024 ** 2,
+    gb: 1000 ** 3,
+    gib: 1024 ** 3,
+  };
+  return Math.floor(Number(match[1]) * (units[(match[2] || "b").toLowerCase()] || 1));
+}
+
+export async function loadConfig(root, explicitPath) {
+  const candidates = explicitPath
+    ? [path.resolve(explicitPath)]
+    : [
+        path.join(root, "context-armor.config.json"),
+        path.join(root, ".contextarmorrc.json"),
+      ];
+
+  let userConfig = {};
+  let configPath = null;
+  for (const candidate of candidates) {
+    try {
+      userConfig = JSON.parse(await fs.readFile(candidate, "utf8"));
+      configPath = candidate;
+      break;
+    } catch (error) {
+      if (error?.code === "ENOENT") continue;
+      if (error instanceof SyntaxError) {
+        throw new Error(`Invalid JSON in ${candidate}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  const config = {
+    ...defaultConfig,
+    ...userConfig,
+    ignore: [...defaultConfig.ignore, ...(userConfig.ignore || [])],
+    disabledRules: [...(userConfig.disabledRules || [])],
+    severity: { ...(userConfig.severity || {}) },
+  };
+  config.maxFileSize = parseSize(config.maxFileSize);
+
+  return { config, configPath };
+}
+
+export { parseSize };

package/src/documents.js

@@ -0,0 +1,154 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { inflateRawSync } from "node:zlib";
+
+const OFFICE_EXTENSIONS = new Set([".docx", ".xlsx", ".pptx"]);
+const IMAGE_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".webp",
+  ".tif",
+  ".tiff",
+  ".bmp",
+  ".heic",
+]);
+
+function decodeXml(value) {
+  return value
+    .replace(/<w:tab\/>/g, "\t")
+    .replace(/<w:br\/>/g, "\n")
+    .replace(/<\/(?:w:p|a:p|row)>/g, "\n")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&")
+    .replace(/&#(\d+);/g, (_, number) => String.fromCodePoint(Number(number)))
+    .replace(/[ \t]+/g, " ")
+    .replace(/\n[ \t]+/g, "\n");
+}
+
+function findEndOfCentralDirectory(buffer) {
+  const signature = 0x06054b50;
+  const start = Math.max(0, buffer.length - 65_557);
+  for (let offset = buffer.length - 22; offset >= start; offset -= 1) {
+    if (buffer.readUInt32LE(offset) === signature) return offset;
+  }
+  return -1;
+}
+
+export function readZipEntries(buffer, limits = {}) {
+  const maxEntries = limits.maxEntries ?? 10_000;
+  const maxOutput = limits.maxOutput ?? 32 * 1024 * 1024;
+  const eocd = findEndOfCentralDirectory(buffer);
+  if (eocd < 0) throw new Error("ZIP central directory not found");
+
+  const entryCount = Math.min(buffer.readUInt16LE(eocd + 10), maxEntries);
+  let offset = buffer.readUInt32LE(eocd + 16);
+  let outputBytes = 0;
+  const entries = [];
+
+  for (let index = 0; index < entryCount; index += 1) {
+    if (offset + 46 > buffer.length || buffer.readUInt32LE(offset) !== 0x02014b50) break;
+    const method = buffer.readUInt16LE(offset + 10);
+    const compressedSize = buffer.readUInt32LE(offset + 20);
+    const uncompressedSize = buffer.readUInt32LE(offset + 24);
+    const nameLength = buffer.readUInt16LE(offset + 28);
+    const extraLength = buffer.readUInt16LE(offset + 30);
+    const commentLength = buffer.readUInt16LE(offset + 32);
+    const localOffset = buffer.readUInt32LE(offset + 42);
+    const name = buffer.subarray(offset + 46, offset + 46 + nameLength).toString("utf8");
+    offset += 46 + nameLength + extraLength + commentLength;
+
+    if (
+      name.endsWith("/") ||
+      uncompressedSize > maxOutput ||
+      outputBytes + uncompressedSize > maxOutput ||
+      localOffset + 30 > buffer.length ||
+      buffer.readUInt32LE(localOffset) !== 0x04034b50
+    ) {
+      continue;
+    }
+
+    const localNameLength = buffer.readUInt16LE(localOffset + 26);
+    const localExtraLength = buffer.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + localNameLength + localExtraLength;
+    const dataEnd = dataStart + compressedSize;
+    if (dataEnd > buffer.length) continue;
+
+    const compressed = buffer.subarray(dataStart, dataEnd);
+    let data;
+    if (method === 0) data = compressed;
+    else if (method === 8) data = inflateRawSync(compressed, { maxOutputLength: maxOutput });
+    else continue;
+
+    outputBytes += data.length;
+    entries.push({ name, data });
+  }
+  return entries;
+}
+
+export async function extractOfficeText(file, maxBytes) {
+  const buffer = await fs.readFile(file);
+  const entries = readZipEntries(buffer, { maxOutput: Math.max(maxBytes * 4, 32 * 1024 * 1024) });
+  const relevant = entries.filter(({ name }) => {
+    if (!name.endsWith(".xml")) return false;
+    return /^(?:word\/|xl\/(?:sharedStrings|worksheets\/)|ppt\/(?:slides|notesSlides)\/)/.test(
+      name,
+    );
+  });
+  return relevant.map(({ data }) => decodeXml(data.toString("utf8"))).join("\n");
+}
+
+function commandText(command, args, maxBytes) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    timeout: 20_000,
+    maxBuffer: maxBytes,
+    windowsHide: true,
+  });
+  if (result.error || result.status !== 0) return null;
+  return result.stdout || "";
+}
+
+export async function extractDocument(file, options) {
+  const extension = path.extname(file).toLowerCase();
+  if (OFFICE_EXTENSIONS.has(extension)) {
+    try {
+      return {
+        text: await extractOfficeText(file, options.maxFileSize),
+        inspected: true,
+        extractor: "office-xml",
+      };
+    } catch (error) {
+      return { text: "", inspected: false, extractor: "office-xml", error: error.message };
+    }
+  }
+  if (extension === ".pdf") {
+    const text = commandText("pdftotext", ["-q", "-enc", "UTF-8", file, "-"], options.maxFileSize * 4);
+    return text === null
+      ? { text: "", inspected: false, extractor: "pdftotext" }
+      : { text, inspected: true, extractor: "pdftotext" };
+  }
+  if (IMAGE_EXTENSIONS.has(extension)) {
+    if (!options.ocr) return { text: "", inspected: false, extractor: "ocr-disabled" };
+    const text = commandText(
+      "tesseract",
+      [file, "stdout", "-l", options.ocrLanguages || "eng+kor", "--psm", "6"],
+      options.maxFileSize * 4,
+    );
+    return text === null
+      ? { text: "", inspected: false, extractor: "tesseract" }
+      : { text, inspected: true, extractor: "tesseract" };
+  }
+  return null;
+}
+
+export function isDocumentExtension(extension) {
+  return OFFICE_EXTENSIONS.has(extension) || extension === ".pdf" || IMAGE_EXTENSIONS.has(extension);
+}
+
+export { decodeXml, IMAGE_EXTENSIONS, OFFICE_EXTENSIONS };

package/src/ignore.js

@@ -0,0 +1,87 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+function normalize(value) {
+  return value.split(path.sep).join("/").replace(/^\.\//, "");
+}
+
+export function globToRegExp(glob) {
+  let source = "";
+  const raw = normalize(glob);
+  const directoryOnly = raw.endsWith("/");
+  const normalized = directoryOnly ? raw.slice(0, -1) : raw;
+  for (let index = 0; index < normalized.length; index += 1) {
+    const character = normalized[index];
+    const next = normalized[index + 1];
+    if (character === "*" && next === "*") {
+      const after = normalized[index + 2];
+      if (after === "/") {
+        source += "(?:.*/)?";
+        index += 2;
+      } else {
+        source += ".*";
+        index += 1;
+      }
+    } else if (character === "*") {
+      source += "[^/]*";
+    } else if (character === "?") {
+      source += "[^/]";
+    } else if (character === "/") {
+      source += "\\/";
+    } else {
+      source += character.replace(/[|\\{}()[\]^$+?.-]/g, "\\$&");
+    }
+  }
+
+  const anchored = normalized.startsWith("/");
+  const prefix = anchored ? "^" : "(?:^|/)";
+  const suffix = directoryOnly ? "(?:/.*)?$" : "(?:$|/.*$)";
+  return new RegExp(`${prefix}${source.replace(/^\\\//, "")}${suffix}`);
+}
+
+function parseIgnoreLines(contents) {
+  return contents
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith("#"))
+    .map((line) => ({
+      negated: line.startsWith("!"),
+      pattern: line.startsWith("!") ? line.slice(1) : line,
+    }))
+    .filter((entry) => entry.pattern);
+}
+
+async function readOptional(file) {
+  try {
+    return await fs.readFile(file, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return "";
+    throw error;
+  }
+}
+
+export async function createIgnoreMatcher(root, config) {
+  const entries = config.ignore.map((pattern) => ({ pattern, negated: false }));
+  const ownIgnore = await readOptional(path.join(root, ".contextarmorignore"));
+  entries.push(...parseIgnoreLines(ownIgnore));
+  if (config.respectGitignore) {
+    const gitIgnore = await readOptional(path.join(root, ".gitignore"));
+    entries.push(...parseIgnoreLines(gitIgnore));
+  }
+
+  const compiled = entries.map((entry) => ({
+    ...entry,
+    regex: globToRegExp(entry.pattern),
+  }));
+
+  return (relativePath, isDirectory = false) => {
+    const candidate = normalize(relativePath) + (isDirectory ? "/" : "");
+    let ignored = false;
+    for (const entry of compiled) {
+      if (entry.regex.test(candidate)) ignored = !entry.negated;
+    }
+    return ignored;
+  };
+}
+
+export { normalize, parseIgnoreLines };

package/src/index.js

@@ -0,0 +1,4 @@
+export { scan } from "./scanner.js";
+export { defaultConfig, loadConfig } from "./config.js";
+export { contentRules, filenameRules, severityRank } from "./rules.js";
+export { formatJson, formatPretty, formatSarif } from "./reporters.js";

package/src/policy.js

@@ -0,0 +1,85 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { severityRank } from "./rules.js";
+
+const BLOCK_START = "# context-armor:start";
+const BLOCK_END = "# context-armor:end";
+
+async function readOptional(file) {
+  try {
+    return await fs.readFile(file, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return "";
+    throw error;
+  }
+}
+
+async function writeMarkedBlock(file, paths) {
+  const existing = await readOptional(file);
+  const start = existing.indexOf(BLOCK_START);
+  const end = existing.indexOf(BLOCK_END);
+  let clean = existing;
+  if (start >= 0 && end >= start) {
+    clean = `${existing.slice(0, start)}${existing.slice(end + BLOCK_END.length)}`;
+  }
+  clean = clean.trimEnd();
+  const block = [BLOCK_START, "# Generated by Context Armor. Re-run `context-armor protect`.", ...paths, BLOCK_END].join(
+    "\n",
+  );
+  await fs.writeFile(file, `${clean ? `${clean}\n\n` : ""}${block}\n`, "utf8");
+}
+
+async function writeClaudePolicy(root, protectedPaths) {
+  const directory = path.join(root, ".claude");
+  const file = path.join(directory, "settings.local.json");
+  await fs.mkdir(directory, { recursive: true });
+  let settings = {};
+  const current = await readOptional(file);
+  if (current.trim()) {
+    try {
+      settings = JSON.parse(current);
+    } catch {
+      throw new Error(`Cannot update invalid JSON: ${file}`);
+    }
+  }
+  settings.permissions ||= {};
+  const existing = new Set(settings.permissions.deny || []);
+  for (const protectedPath of protectedPaths) {
+    existing.add(`Read(${protectedPath})`);
+    existing.add(`Edit(${protectedPath})`);
+  }
+  settings.permissions.deny = [...existing].sort();
+  await fs.writeFile(file, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+}
+
+export function protectedPathsFromFindings(findings, threshold = "high") {
+  const thresholdRank = severityRank[threshold];
+  return [
+    ...new Set(
+      findings
+        .filter((finding) => severityRank[finding.severity] <= thresholdRank)
+        .map((finding) => finding.path),
+    ),
+  ].sort();
+}
+
+export async function writeProtectionPolicies(root, protectedPaths) {
+  const stateDirectory = path.join(root, ".context-armor");
+  await fs.mkdir(stateDirectory, { recursive: true });
+  await fs.writeFile(
+    path.join(stateDirectory, "protected-paths.txt"),
+    `${protectedPaths.join("\n")}${protectedPaths.length ? "\n" : ""}`,
+    "utf8",
+  );
+  await Promise.all([
+    writeMarkedBlock(path.join(root, ".cursorignore"), protectedPaths),
+    writeMarkedBlock(path.join(root, ".geminiignore"), protectedPaths),
+    writeClaudePolicy(root, protectedPaths),
+  ]);
+  return [
+    ".context-armor/protected-paths.txt",
+    ".cursorignore",
+    ".geminiignore",
+    ".claude/settings.local.json",
+  ];
+}