mdenc 0.1.3 → 2.0.0

package/dist/cli.js

@@ -1,35 +1,404 @@
 #!/usr/bin/env node
-import {
-  constantTimeEqual,
-  decrypt,
-  deriveKeys,
-  deriveMasterKey,
-  encrypt,
-  findGitRoot,
-  findMarkedDirs,
-  fromBase64,
-  getHooksDir,
-  getMdFilesInDir,
-  getMdencFilesInDir,
-  gitAdd,
-  gitRmCached,
-  isFileTracked,
-  parseHeader,
-  postCheckoutHook,
-  postMergeHook,
-  postRewriteHook,
-  preCommitHook,
-  resolvePassword,
-  verifyHeader,
-  zeroize
-} from "./chunk-DQSJGHST.js";
 
 // src/cli.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 
-// src/seal.ts
+// src/crypto/encrypt.ts
+import { hmac as hmac3 } from "@noble/hashes/hmac";
+import { sha256 as sha2564 } from "@noble/hashes/sha256";
+
+// src/crypto/aead.ts
+import { xchacha20poly1305 } from "@noble/ciphers/chacha";
 import { hmac } from "@noble/hashes/hmac";
 import { sha256 } from "@noble/hashes/sha256";
+var NONCE_LENGTH = 24;
+function buildAAD(fileId) {
+  const fileIdHex = bytesToHex(fileId);
+  const aadString = `mdenc:v1
+${fileIdHex}`;
+  return new TextEncoder().encode(aadString);
+}
+function deriveNonce(nonceKey, plaintext) {
+  const full = hmac(sha256, nonceKey, plaintext);
+  return full.slice(0, NONCE_LENGTH);
+}
+function encryptChunk(encKey, nonceKey, plaintext, fileId) {
+  const nonce = deriveNonce(nonceKey, plaintext);
+  const aad = buildAAD(fileId);
+  const cipher = xchacha20poly1305(encKey, nonce, aad);
+  const ciphertext = cipher.encrypt(plaintext);
+  const result = new Uint8Array(NONCE_LENGTH + ciphertext.length);
+  result.set(nonce, 0);
+  result.set(ciphertext, NONCE_LENGTH);
+  return result;
+}
+function decryptChunk(encKey, payload, fileId) {
+  if (payload.length < NONCE_LENGTH + 16) {
+    throw new Error("Chunk payload too short");
+  }
+  const nonce = payload.slice(0, NONCE_LENGTH);
+  const ciphertext = payload.slice(NONCE_LENGTH);
+  const aad = buildAAD(fileId);
+  const cipher = xchacha20poly1305(encKey, nonce, aad);
+  try {
+    return cipher.decrypt(ciphertext);
+  } catch {
+    throw new Error("Chunk authentication failed");
+  }
+}
+function bytesToHex(bytes) {
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+// src/crypto/chunking.ts
+var DEFAULT_MAX_CHUNK_SIZE = 65536;
+function chunkByParagraph(text, maxSize = DEFAULT_MAX_CHUNK_SIZE) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  if (normalized.length === 0) {
+    return [""];
+  }
+  const chunks = [];
+  const boundary = /\n{2,}/g;
+  let lastEnd = 0;
+  let match;
+  while ((match = boundary.exec(normalized)) !== null) {
+    const chunkEnd = match.index + match[0].length;
+    chunks.push(normalized.slice(lastEnd, chunkEnd));
+    lastEnd = chunkEnd;
+  }
+  if (lastEnd < normalized.length) {
+    chunks.push(normalized.slice(lastEnd));
+  } else if (chunks.length === 0) {
+    chunks.push(normalized);
+  }
+  const result = [];
+  for (const chunk of chunks) {
+    if (byteLength(chunk) <= maxSize) {
+      result.push(chunk);
+    } else {
+      result.push(...splitAtByteLimit(chunk, maxSize));
+    }
+  }
+  return result;
+}
+function chunkByFixedSize(text, size) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  if (normalized.length === 0) {
+    return [""];
+  }
+  const bytes = new TextEncoder().encode(normalized);
+  if (bytes.length <= size) {
+    return [normalized];
+  }
+  const chunks = [];
+  const decoder = new TextDecoder();
+  let offset = 0;
+  while (offset < bytes.length) {
+    const end = Math.min(offset + size, bytes.length);
+    let adjusted = end;
+    if (adjusted < bytes.length) {
+      while (adjusted > offset && (bytes[adjusted] & 192) === 128) {
+        adjusted--;
+      }
+    }
+    chunks.push(decoder.decode(bytes.slice(offset, adjusted)));
+    offset = adjusted;
+  }
+  return chunks;
+}
+function byteLength(s) {
+  return new TextEncoder().encode(s).length;
+}
+function splitAtByteLimit(text, maxSize) {
+  const bytes = new TextEncoder().encode(text);
+  const decoder = new TextDecoder();
+  const parts = [];
+  let offset = 0;
+  while (offset < bytes.length) {
+    let end = Math.min(offset + maxSize, bytes.length);
+    if (end < bytes.length) {
+      while (end > offset && (bytes[end] & 192) === 128) {
+        end--;
+      }
+    }
+    parts.push(decoder.decode(bytes.slice(offset, end)));
+    offset = end;
+  }
+  return parts;
+}
+
+// src/crypto/crypto-utils.ts
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a[i] ^ b[i];
+  }
+  return diff === 0;
+}
+function zeroize(...arrays) {
+  for (const arr of arrays) {
+    arr.fill(0);
+  }
+}
+
+// src/crypto/header.ts
+import { randomBytes } from "@noble/ciphers/webcrypto";
+import { hmac as hmac2 } from "@noble/hashes/hmac";
+import { sha256 as sha2562 } from "@noble/hashes/sha256";
+
+// src/crypto/types.ts
+var DEFAULT_SCRYPT_PARAMS = {
+  N: 16384,
+  r: 8,
+  p: 1
+};
+var SCRYPT_BOUNDS = {
+  N: { min: 1024, max: 1048576 },
+  // 2^10 – 2^20
+  r: { min: 1, max: 64 },
+  p: { min: 1, max: 16 }
+};
+
+// src/crypto/header.ts
+function generateSalt() {
+  return randomBytes(16);
+}
+function generateFileId() {
+  return randomBytes(16);
+}
+function serializeHeader(header) {
+  const saltB64 = toBase64(header.salt);
+  const fileIdB64 = toBase64(header.fileId);
+  const { N, r, p } = header.scrypt;
+  return `mdenc:v1 salt_b64=${saltB64} file_id_b64=${fileIdB64} scrypt=N=${N},r=${r},p=${p}`;
+}
+function parseHeader(line) {
+  if (!line.startsWith("mdenc:v1 ")) {
+    throw new Error("Invalid header: missing mdenc:v1 prefix");
+  }
+  const saltMatch = line.match(/salt_b64=([A-Za-z0-9+/=]+)/);
+  if (!saltMatch?.[1]) throw new Error("Invalid header: missing salt_b64");
+  const salt = fromBase64(saltMatch[1]);
+  if (salt.length !== 16) throw new Error("Invalid header: salt must be 16 bytes");
+  const fileIdMatch = line.match(/file_id_b64=([A-Za-z0-9+/=]+)/);
+  if (!fileIdMatch?.[1]) throw new Error("Invalid header: missing file_id_b64");
+  const fileId = fromBase64(fileIdMatch[1]);
+  if (fileId.length !== 16) throw new Error("Invalid header: file_id must be 16 bytes");
+  const scryptMatch = line.match(/scrypt=N=(\d+),r=(\d+),p=(\d+)/);
+  if (!scryptMatch?.[1] || !scryptMatch[2] || !scryptMatch[3])
+    throw new Error("Invalid header: missing scrypt parameters");
+  const scryptParams = {
+    N: parseInt(scryptMatch[1], 10),
+    r: parseInt(scryptMatch[2], 10),
+    p: parseInt(scryptMatch[3], 10)
+  };
+  validateScryptParams(scryptParams);
+  return { version: "v1", salt, fileId, scrypt: scryptParams };
+}
+function validateScryptParams(params) {
+  const { N, r, p } = SCRYPT_BOUNDS;
+  if (params.N < N.min || params.N > N.max) {
+    throw new Error(`Invalid scrypt N: ${params.N} (must be ${N.min}\u2013${N.max})`);
+  }
+  if ((params.N & params.N - 1) !== 0) {
+    throw new Error(`Invalid scrypt N: ${params.N} (must be a power of 2)`);
+  }
+  if (params.r < r.min || params.r > r.max) {
+    throw new Error(`Invalid scrypt r: ${params.r} (must be ${r.min}\u2013${r.max})`);
+  }
+  if (params.p < p.min || params.p > p.max) {
+    throw new Error(`Invalid scrypt p: ${params.p} (must be ${p.min}\u2013${p.max})`);
+  }
+}
+function authenticateHeader(headerKey, headerLine) {
+  const headerBytes = new TextEncoder().encode(headerLine);
+  return hmac2(sha2562, headerKey, headerBytes);
+}
+function verifyHeader(headerKey, headerLine, hmacBytes) {
+  const computed = authenticateHeader(headerKey, headerLine);
+  return constantTimeEqual(computed, hmacBytes);
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function fromBase64(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// src/crypto/kdf.ts
+import { hkdf } from "@noble/hashes/hkdf";
+import { scrypt } from "@noble/hashes/scrypt";
+import { sha256 as sha2563 } from "@noble/hashes/sha256";
+var ENC_INFO = new TextEncoder().encode("mdenc-v1-enc");
+var HDR_INFO = new TextEncoder().encode("mdenc-v1-hdr");
+var NONCE_INFO = new TextEncoder().encode("mdenc-v1-nonce");
+function normalizePassword(password) {
+  const normalized = password.normalize("NFKC");
+  return new TextEncoder().encode(normalized);
+}
+function deriveMasterKey(password, salt, params = DEFAULT_SCRYPT_PARAMS) {
+  const passwordBytes = normalizePassword(password);
+  try {
+    return scrypt(passwordBytes, salt, {
+      N: params.N,
+      r: params.r,
+      p: params.p,
+      dkLen: 32
+    });
+  } finally {
+    zeroize(passwordBytes);
+  }
+}
+function deriveKeys(masterKey) {
+  const encKey = hkdf(sha2563, masterKey, void 0, ENC_INFO, 32);
+  const headerKey = hkdf(sha2563, masterKey, void 0, HDR_INFO, 32);
+  const nonceKey = hkdf(sha2563, masterKey, void 0, NONCE_INFO, 32);
+  return { encKey, headerKey, nonceKey };
+}
+
+// src/crypto/encrypt.ts
+async function encrypt(plaintext, password, options) {
+  const chunking = options?.chunking ?? "paragraph" /* Paragraph */;
+  const maxChunkSize = options?.maxChunkSize ?? 65536;
+  const scryptParams = options?.scrypt ?? DEFAULT_SCRYPT_PARAMS;
+  let chunks;
+  if (chunking === "fixed-size" /* FixedSize */) {
+    const fixedSize = options?.fixedChunkSize ?? 4096;
+    chunks = chunkByFixedSize(plaintext, fixedSize);
+  } else {
+    chunks = chunkByParagraph(plaintext, maxChunkSize);
+  }
+  let salt;
+  let fileId;
+  let masterKey;
+  const prev = options?.previousFile ? parsePreviousFileHeader(options.previousFile, password) : void 0;
+  if (prev) {
+    salt = prev.salt;
+    fileId = prev.fileId;
+    masterKey = prev.masterKey;
+  } else {
+    salt = generateSalt();
+    fileId = generateFileId();
+    masterKey = deriveMasterKey(password, salt, scryptParams);
+  }
+  const { encKey, headerKey, nonceKey } = deriveKeys(masterKey);
+  try {
+    const header = { version: "v1", salt, fileId, scrypt: scryptParams };
+    const headerLine = serializeHeader(header);
+    const headerHmac = authenticateHeader(headerKey, headerLine);
+    const headerAuthLine = `hdrauth_b64=${toBase64(headerHmac)}`;
+    const chunkLines = [];
+    for (const chunkText of chunks) {
+      const chunkBytes = new TextEncoder().encode(chunkText);
+      const payload = encryptChunk(encKey, nonceKey, chunkBytes, fileId);
+      chunkLines.push(toBase64(payload));
+    }
+    const sealInput = `${headerLine}
+${headerAuthLine}
+${chunkLines.join("\n")}`;
+    const sealData = new TextEncoder().encode(sealInput);
+    const sealHmac = hmac3(sha2564, headerKey, sealData);
+    const sealLine = `seal_b64=${toBase64(sealHmac)}`;
+    return [headerLine, headerAuthLine, ...chunkLines, sealLine, ""].join("\n");
+  } finally {
+    zeroize(masterKey, encKey, headerKey, nonceKey);
+  }
+}
+async function decrypt(fileContent, password) {
+  const lines = fileContent.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  if (lines.length < 3) {
+    throw new Error("Invalid mdenc file: too few lines");
+  }
+  const headerLine = lines[0];
+  const header = parseHeader(headerLine);
+  const authLine = lines[1];
+  const authMatch = authLine.match(/^hdrauth_b64=([A-Za-z0-9+/=]+)$/);
+  if (!authMatch?.[1]) {
+    throw new Error("Invalid mdenc file: missing hdrauth_b64 line");
+  }
+  const headerHmac = fromBase64(authMatch[1]);
+  const masterKey = deriveMasterKey(password, header.salt, header.scrypt);
+  const { encKey, headerKey, nonceKey } = deriveKeys(masterKey);
+  try {
+    if (!verifyHeader(headerKey, headerLine, headerHmac)) {
+      throw new Error("Header authentication failed (wrong password or tampered header)");
+    }
+    const remaining = lines.slice(2);
+    const sealIndex = remaining.findIndex((l) => l.startsWith("seal_b64="));
+    if (sealIndex < 0) {
+      throw new Error("Invalid mdenc file: missing seal");
+    }
+    const chunkLines = remaining.slice(0, sealIndex);
+    if (chunkLines.length === 0) {
+      throw new Error("Invalid mdenc file: no chunk lines");
+    }
+    const sealLine = remaining[sealIndex];
+    const sealMatch = sealLine.match(/^seal_b64=([A-Za-z0-9+/=]+)$/);
+    if (!sealMatch?.[1]) throw new Error("Invalid mdenc file: malformed seal line");
+    const storedSealHmac = fromBase64(sealMatch[1]);
+    const sealInput = `${headerLine}
+${authLine}
+${chunkLines.join("\n")}`;
+    const sealData = new TextEncoder().encode(sealInput);
+    const computedSealHmac = hmac3(sha2564, headerKey, sealData);
+    if (!constantTimeEqual(computedSealHmac, storedSealHmac)) {
+      throw new Error("Seal verification failed (file tampered or chunks reordered)");
+    }
+    const plaintextParts = [];
+    for (const line of chunkLines) {
+      const payload = fromBase64(line);
+      const decrypted = decryptChunk(encKey, payload, header.fileId);
+      plaintextParts.push(new TextDecoder().decode(decrypted));
+    }
+    return plaintextParts.join("");
+  } finally {
+    zeroize(masterKey, encKey, headerKey, nonceKey);
+  }
+}
+function parsePreviousFileHeader(fileContent, password) {
+  try {
+    const lines = fileContent.split("\n");
+    if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+    if (lines.length < 3) return void 0;
+    const headerLine = lines[0];
+    const header = parseHeader(headerLine);
+    const authLine = lines[1];
+    const authMatch = authLine.match(/^hdrauth_b64=([A-Za-z0-9+/=]+)$/);
+    if (!authMatch?.[1]) return void 0;
+    const headerHmac = fromBase64(authMatch[1]);
+    const masterKey = deriveMasterKey(password, header.salt, header.scrypt);
+    const { encKey, headerKey, nonceKey } = deriveKeys(masterKey);
+    if (!verifyHeader(headerKey, headerLine, headerHmac)) {
+      zeroize(masterKey, encKey, headerKey, nonceKey);
+      return void 0;
+    }
+    zeroize(encKey, headerKey, nonceKey);
+    return { salt: header.salt, fileId: header.fileId, masterKey };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/crypto/seal.ts
+import { hmac as hmac4 } from "@noble/hashes/hmac";
+import { sha256 as sha2565 } from "@noble/hashes/sha256";
 async function verifySeal(fileContent, password) {
   const lines = fileContent.split("\n");
   if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
@@ -38,10 +407,10 @@ async function verifySeal(fileContent, password) {
   const header = parseHeader(headerLine);
   const authLine = lines[1];
   const authMatch = authLine.match(/^hdrauth_b64=([A-Za-z0-9+/=]+)$/);
-  if (!authMatch) throw new Error("Invalid mdenc file: missing hdrauth_b64 line");
+  if (!authMatch?.[1]) throw new Error("Invalid mdenc file: missing hdrauth_b64 line");
   const headerHmac = fromBase64(authMatch[1]);
   const masterKey = deriveMasterKey(password, header.salt, header.scrypt);
-  const { headerKey, nonceKey } = deriveKeys(masterKey);
+  const { encKey, headerKey, nonceKey } = deriveKeys(masterKey);
   try {
     if (!verifyHeader(headerKey, headerLine, headerHmac)) {
       throw new Error("Header authentication failed");
@@ -52,194 +421,536 @@ async function verifySeal(fileContent, password) {
       throw new Error("File is not sealed: no seal_b64 line found");
     }
     const chunkLines = chunkAndSealLines.slice(0, sealIndex);
-    const sealMatch = chunkAndSealLines[sealIndex].match(/^seal_b64=([A-Za-z0-9+/=]+)$/);
-    if (!sealMatch) throw new Error("Invalid seal line");
+    const sealLine = chunkAndSealLines[sealIndex];
+    const sealMatch = sealLine.match(/^seal_b64=([A-Za-z0-9+/=]+)$/);
+    if (!sealMatch?.[1]) throw new Error("Invalid seal line");
     const storedHmac = fromBase64(sealMatch[1]);
-    const sealInput = headerLine + "\n" + authLine + "\n" + chunkLines.join("\n");
+    const sealInput = `${headerLine}
+${authLine}
+${chunkLines.join("\n")}`;
     const sealData = new TextEncoder().encode(sealInput);
-    const computed = hmac(sha256, headerKey, sealData);
+    const computed = hmac4(sha2565, headerKey, sealData);
     return constantTimeEqual(computed, storedHmac);
   } finally {
-    zeroize(masterKey, headerKey, nonceKey);
+    zeroize(masterKey, encKey, headerKey, nonceKey);
   }
 }
 
-// src/git/init.ts
-import { readFileSync, writeFileSync, existsSync, chmodSync, unlinkSync } from "fs";
+// src/git/diff-driver.ts
+import { execFileSync } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
 import { join } from "path";
-var MARKER = "# mdenc-hook-marker";
-var HOOK_NAMES = [
-  "pre-commit",
-  "post-checkout",
-  "post-merge",
-  "post-rewrite"
-];
-function hookBlock(hookName) {
-  return `
-${MARKER}
-if command -v mdenc >/dev/null 2>&1; then
-  mdenc ${hookName}
-elif [ -x "./node_modules/.bin/mdenc" ]; then
-  ./node_modules/.bin/mdenc ${hookName}
-else
-  echo "mdenc: not found, skipping ${hookName} hook" >&2
-fi`;
-}
-function newHookScript(hookName) {
-  return `#!/bin/sh${hookBlock(hookName)}
-`;
-}
-function isBinary(content) {
-  return content.slice(0, 512).includes("\0");
-}
-function hasShellShebang(content) {
-  const firstLine = content.split("\n")[0];
-  return /^#!.*\b(sh|bash|zsh|dash)\b/.test(firstLine);
-}
-function looksLikeFrameworkHook(content) {
-  const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
-  if (lines.length <= 2) {
-    return lines.some((l) => /^\.\s+"/.test(l.trim()) || /^exec\s+/.test(l.trim()));
-  }
-  return false;
-}
-function printManualInstructions(hookName) {
-  process.stderr.write(
-    `mdenc: ${hookName} hook exists but has an unrecognized format.
-       Add the following to your hook manually:
+async function diffDriverCommand(args) {
+  const [path, oldFile, oldHex, , newFile, newHex] = args;
+  if (!path || !oldFile || !newFile) {
+    process.stderr.write("mdenc diff-driver: insufficient arguments\n");
+    process.exit(1);
+  }
+  const oldEnc = catBlob(oldHex);
+  const newEnc = catBlob(newHex);
+  if (oldEnc !== null || newEnc !== null) {
+    const tmp = mkdtempSync(join(tmpdir(), "mdenc-diff-"));
+    try {
+      const oldTmp = join(tmp, "old");
+      const newTmp = join(tmp, "new");
+      writeFileSync(oldTmp, oldEnc ?? "");
+      writeFileSync(newTmp, newEnc ?? "");
+      const encDiff = unifiedDiff(oldTmp, newTmp, `a/${path}`, `b/${path}`);
+      if (encDiff) process.stdout.write(encDiff);
+    } finally {
+      rmSync(tmp, { recursive: true });
+    }
+  }
+  const plainDiff = unifiedDiff(oldFile, newFile, `a/${path}`, `b/${path}`);
+  if (plainDiff) {
+    const annotated = plainDiff.replace(
+      /^(@@ .+ @@)(.*)/gm,
+      "$1 decrypted \u2014 not stored in repository"
+    );
+    process.stdout.write(annotated);
+  }
+}
+function catBlob(hex) {
+  if (!hex || hex === "." || /^0+$/.test(hex)) return null;
+  try {
+    return execFileSync("git", ["cat-file", "blob", hex], { encoding: "utf-8" });
+  } catch {
+    return null;
+  }
+}
+function unifiedDiff(oldFile, newFile, oldLabel, newLabel) {
+  try {
+    return execFileSync("diff", ["-u", "--label", oldLabel, "--label", newLabel, oldFile, newFile], {
+      encoding: "utf-8"
+    }) || null;
+  } catch (e) {
+    const err = e;
+    if (err.status === 1 && err.stdout) return err.stdout;
+    return null;
+  }
+}
 
-  ${MARKER}
-  if command -v mdenc >/dev/null 2>&1; then
-    mdenc ${hookName}
-  elif [ -x "./node_modules/.bin/mdenc" ]; then
-    ./node_modules/.bin/mdenc ${hookName}
-  fi
+// src/git/password.ts
+import { readFileSync } from "fs";
+import { join as join2 } from "path";
+var PASSWORD_FILE = ".mdenc-password";
+function resolvePassword(repoRoot) {
+  const envPassword = process.env["MDENC_PASSWORD"];
+  if (envPassword) return envPassword;
+  try {
+    const content = readFileSync(join2(repoRoot, PASSWORD_FILE), "utf-8").trim();
+    if (content.length > 0) return content;
+  } catch {
+  }
+  return null;
+}
 
-`
-  );
+// src/git/utils.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { readdirSync, statSync } from "fs";
+import { join as join3 } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
+var MARKER_FILE = ".mdenc.conf";
+function findGitRoot() {
+  try {
+    return execFileSync2("git", ["rev-parse", "--show-toplevel"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    throw new Error("Not a git repository");
+  }
 }
-async function initCommand() {
+function gitShow(repoRoot, ref, path) {
+  try {
+    return execFileSync2("git", ["show", `${ref}:${path}`], {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return void 0;
+  }
+}
+function findMarkedDirs(repoRoot) {
+  const results = [];
+  walkForMarker(repoRoot, results);
+  return results;
+}
+function walkForMarker(dir, results) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  if (entries.includes(MARKER_FILE)) {
+    results.push(dir);
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry) || entry.startsWith(".")) continue;
+    const full = join3(dir, entry);
+    try {
+      if (statSync(full).isDirectory()) {
+        walkForMarker(full, results);
+      }
+    } catch {
+    }
+  }
+}
+function getMdFilesInDir(dir) {
+  try {
+    return readdirSync(dir).filter((f) => f.endsWith(".md") && statSync(join3(dir, f)).isFile());
+  } catch {
+    return [];
+  }
+}
+function gitAdd(repoRoot, files) {
+  if (files.length === 0) return;
+  execFileSync2("git", ["add", "--", ...files], {
+    cwd: repoRoot,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+
+// src/git/filter.ts
+async function cleanFilter(pathname, plaintext, password, repoRoot) {
+  const previousFile = gitShow(repoRoot, "HEAD", pathname);
+  return encrypt(plaintext, password, previousFile ? { previousFile } : {});
+}
+async function smudgeFilter(content, password) {
+  if (!password || !content.startsWith("mdenc:v1")) {
+    return content;
+  }
+  try {
+    return await decrypt(content, password);
+  } catch {
+    return content;
+  }
+}
+async function simpleCleanFilter(pathname) {
+  const repoRoot = findGitRoot();
+  const password = resolvePassword(repoRoot);
+  if (!password) {
+    process.stderr.write("mdenc: no password available, cannot encrypt\n");
+    process.exit(1);
+  }
+  const input = await readStdin();
+  const encrypted = await cleanFilter(pathname, input, password, repoRoot);
+  process.stdout.write(encrypted);
+}
+async function simpleSmudgeFilter() {
   const repoRoot = findGitRoot();
-  const hooksDir = getHooksDir();
-  for (const hookName of HOOK_NAMES) {
-    const hookPath = join(hooksDir, hookName);
-    if (!existsSync(hookPath)) {
-      writeFileSync(hookPath, newHookScript(hookName));
-      chmodSync(hookPath, 493);
-      console.log(`Installed ${hookName} hook`);
-      continue;
+  const password = resolvePassword(repoRoot);
+  const input = await readStdin();
+  const output = await smudgeFilter(input, password);
+  process.stdout.write(output);
+}
+function readStdin() {
+  return new Promise((resolve2) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.resume();
+  });
+}
+
+// src/git/filter-process.ts
+var FLUSH = Buffer.from("0000", "ascii");
+var MAX_PKT_DATA = 65516;
+function writePktLine(data) {
+  const payload = Buffer.from(data, "utf-8");
+  const len = (payload.length + 4).toString(16).padStart(4, "0");
+  process.stdout.write(len, "ascii");
+  process.stdout.write(payload);
+}
+function writeFlush() {
+  process.stdout.write(FLUSH);
+}
+function writeBinaryPktLines(data) {
+  let offset = 0;
+  while (offset < data.length) {
+    const chunk = data.subarray(offset, offset + MAX_PKT_DATA);
+    const len = (chunk.length + 4).toString(16).padStart(4, "0");
+    process.stdout.write(len, "ascii");
+    process.stdout.write(chunk);
+    offset += chunk.length;
+  }
+}
+var PktLineReader = class {
+  buf = Buffer.alloc(0);
+  // biome-ignore lint/suspicious/noConfusingVoidType: standard Promise resolve signature
+  resolveWait = null;
+  ended = false;
+  constructor(stream) {
+    stream.on("data", (chunk) => {
+      this.buf = Buffer.concat([this.buf, chunk]);
+      if (this.resolveWait) {
+        const r = this.resolveWait;
+        this.resolveWait = null;
+        r();
+      }
+    });
+    stream.on("end", () => {
+      this.ended = true;
+      if (this.resolveWait) {
+        const r = this.resolveWait;
+        this.resolveWait = null;
+        r();
+      }
+    });
+    stream.resume();
+  }
+  async waitForData() {
+    if (this.buf.length > 0 || this.ended) return;
+    return new Promise((resolve2) => {
+      this.resolveWait = resolve2;
+    });
+  }
+  async readExact(n) {
+    while (this.buf.length < n) {
+      if (this.ended) return null;
+      await this.waitForData();
     }
-    const content = readFileSync(hookPath, "utf-8");
-    if (content.includes(MARKER)) {
-      console.log(`${hookName} hook already installed (skipped)`);
-      continue;
+    const result = this.buf.subarray(0, n);
+    this.buf = this.buf.subarray(n);
+    return result;
+  }
+  /** Read one pkt-line. Returns string for data, null for flush, undefined for EOF. */
+  async readPacket() {
+    const lenBuf = await this.readExact(4);
+    if (!lenBuf) return void 0;
+    const lenStr = lenBuf.toString("ascii");
+    const len = parseInt(lenStr, 16);
+    if (len === 0) return null;
+    if (len <= 4) throw new Error(`Invalid pkt-line length: ${len}`);
+    const payload = await this.readExact(len - 4);
+    if (!payload) throw new Error("Unexpected EOF in pkt-line payload");
+    return payload.toString("utf-8");
+  }
+  /** Read lines until flush. Returns array of strings (newlines stripped). */
+  async readUntilFlush() {
+    const lines = [];
+    while (true) {
+      const pkt = await this.readPacket();
+      if (pkt === null || pkt === void 0) break;
+      lines.push(pkt.replace(/\n$/, ""));
     }
-    if (isBinary(content)) {
-      process.stderr.write(
-        `mdenc: ${hookName} hook appears to be a binary file. Skipping.
-`
-      );
-      printManualInstructions(hookName);
-      continue;
+    return lines;
+  }
+  /** Read binary content until flush. Returns concatenated buffer. */
+  async readContentUntilFlush() {
+    const chunks = [];
+    while (true) {
+      const lenBuf = await this.readExact(4);
+      if (!lenBuf) break;
+      const len = parseInt(lenBuf.toString("ascii"), 16);
+      if (len === 0) break;
+      if (len <= 4) throw new Error(`Invalid pkt-line length: ${len}`);
+      const payload = await this.readExact(len - 4);
+      if (!payload) throw new Error("Unexpected EOF in pkt-line content");
+      chunks.push(payload);
     }
-    if (!hasShellShebang(content)) {
-      process.stderr.write(
-        `mdenc: ${hookName} hook has no shell shebang. Skipping.
-`
-      );
-      printManualInstructions(hookName);
-      continue;
+    return Buffer.concat(chunks);
+  }
+};
+async function filterProcessMain() {
+  const repoRoot = findGitRoot();
+  const password = resolvePassword(repoRoot);
+  const reader = new PktLineReader(process.stdin);
+  const welcome = await reader.readUntilFlush();
+  if (!welcome.includes("git-filter-client") || !welcome.includes("version=2")) {
+    process.stderr.write("mdenc: invalid filter protocol handshake\n");
+    process.exit(1);
+  }
+  writePktLine("git-filter-server\n");
+  writePktLine("version=2\n");
+  writeFlush();
+  const caps = await reader.readUntilFlush();
+  if (caps.includes("capability=clean")) writePktLine("capability=clean\n");
+  if (caps.includes("capability=smudge")) writePktLine("capability=smudge\n");
+  writeFlush();
+  while (true) {
+    const commandLines = await reader.readUntilFlush();
+    if (commandLines.length === 0) break;
+    let cmd = "";
+    let pathname = "";
+    for (const line of commandLines) {
+      if (line.startsWith("command=")) cmd = line.slice("command=".length);
+      if (line.startsWith("pathname=")) pathname = line.slice("pathname=".length);
     }
-    if (looksLikeFrameworkHook(content)) {
+    const content = await reader.readContentUntilFlush();
+    const contentStr = content.toString("utf-8");
+    try {
+      let result;
+      if (cmd === "clean") {
+        if (!password) {
+          writePktLine("status=error\n");
+          writeFlush();
+          writeFlush();
+          continue;
+        }
+        result = await cleanFilter(pathname, contentStr, password, repoRoot);
+      } else if (cmd === "smudge") {
+        result = await smudgeFilter(contentStr, password);
+      } else {
+        process.stderr.write(`mdenc: unknown filter command: ${cmd}
+`);
+        writePktLine("status=error\n");
+        writeFlush();
+        writeFlush();
+        continue;
+      }
+      const resultBuf = Buffer.from(result, "utf-8");
+      writePktLine("status=success\n");
+      writeFlush();
+      writeBinaryPktLines(resultBuf);
+      writeFlush();
+      writeFlush();
+    } catch (err) {
       process.stderr.write(
-        `mdenc: ${hookName} hook appears to be managed by a framework. Skipping.
+        `mdenc: filter error for ${pathname}: ${err instanceof Error ? err.message : err}
 `
       );
-      printManualInstructions(hookName);
-      continue;
+      writePktLine("status=error\n");
+      writeFlush();
+      writeFlush();
     }
-    writeFileSync(hookPath, content.trimEnd() + "\n" + hookBlock(hookName) + "\n");
-    chmodSync(hookPath, 493);
-    console.log(`Appended mdenc to existing ${hookName} hook`);
   }
-  const gitignorePath = join(repoRoot, ".gitignore");
-  const entry = ".mdenc-password";
+}
+
+// src/git/genpass.ts
+import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { randomBytes as randomBytes2 } from "@noble/ciphers/webcrypto";
+var PASSWORD_FILE2 = ".mdenc-password";
+function genpassCommand(force) {
+  const repoRoot = findGitRoot();
+  const passwordPath = join4(repoRoot, PASSWORD_FILE2);
+  if (existsSync(passwordPath) && !force) {
+    console.error(`${PASSWORD_FILE2} already exists. Use --force to overwrite.`);
+    process.exit(1);
+  }
+  const password = Buffer.from(randomBytes2(32)).toString("base64url");
+  writeFileSync2(passwordPath, `${password}
+`, { mode: 384 });
+  console.error(`Generated password and wrote to ${PASSWORD_FILE2}`);
+  console.error(password);
+  const gitignorePath = join4(repoRoot, ".gitignore");
+  const entry = PASSWORD_FILE2;
   if (existsSync(gitignorePath)) {
-    const content = readFileSync(gitignorePath, "utf-8");
+    const content = readFileSync2(gitignorePath, "utf-8");
+    const lines = content.split("\n").map((l) => l.trim());
+    if (!lines.includes(entry)) {
+      writeFileSync2(gitignorePath, `${content.trimEnd()}
+${entry}
+`);
+      console.error("Added .mdenc-password to .gitignore");
+    }
+  } else {
+    writeFileSync2(gitignorePath, `${entry}
+`);
+    console.error("Created .gitignore with .mdenc-password");
+  }
+}
+
+// src/git/init.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+var FILTER_CONFIGS = [
+  ["filter.mdenc.process", "mdenc filter-process"],
+  ["filter.mdenc.clean", "mdenc filter-clean %f"],
+  ["filter.mdenc.smudge", "mdenc filter-smudge %f"],
+  ["filter.mdenc.required", "true"],
+  ["diff.mdenc.command", "mdenc diff-driver"]
+];
+function configureGitFilter(repoRoot) {
+  for (const [key, value] of FILTER_CONFIGS) {
+    execFileSync3("git", ["config", "--local", key, value], {
+      cwd: repoRoot,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+}
+function isFilterConfigured(repoRoot) {
+  try {
+    const val = execFileSync3("git", ["config", "--get", "filter.mdenc.process"], {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return val.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function initCommand() {
+  const repoRoot = findGitRoot();
+  if (isFilterConfigured(repoRoot)) {
+    console.log("Git filter already configured (skipped)");
+  } else {
+    configureGitFilter(repoRoot);
+    console.log("Configured git filter (filter.mdenc + diff.mdenc)");
+  }
+  const gitignorePath = join5(repoRoot, ".gitignore");
+  const entry = ".mdenc-password";
+  if (existsSync2(gitignorePath)) {
+    const content = readFileSync3(gitignorePath, "utf-8");
     const lines = content.split("\n").map((l) => l.trim());
     if (!lines.includes(entry)) {
-      writeFileSync(gitignorePath, content.trimEnd() + "\n" + entry + "\n");
+      writeFileSync3(gitignorePath, `${content.trimEnd()}
+${entry}
+`);
       console.log("Added .mdenc-password to .gitignore");
     } else {
       console.log(".mdenc-password already in .gitignore (skipped)");
     }
   } else {
-    writeFileSync(gitignorePath, entry + "\n");
+    writeFileSync3(gitignorePath, `${entry}
+`);
     console.log("Created .gitignore with .mdenc-password");
   }
-  const { decryptAll } = await import("./hooks-7DUHI6MG.js");
-  const { decrypted } = await decryptAll();
-  if (decrypted > 0) {
-    console.log(`Decrypted ${decrypted} existing file(s)`);
+  const markedDirs = findMarkedDirs(repoRoot);
+  if (markedDirs.length > 0) {
+    const { relative: relative3 } = await import("path");
+    for (const dir of markedDirs) {
+      const relDir = relative3(repoRoot, dir) || ".";
+      try {
+        execFileSync3("git", ["checkout", "HEAD", "--", `${relDir}/*.md`], {
+          cwd: repoRoot,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+      }
+    }
   }
   console.log("mdenc git integration initialized.");
 }
-function removeHooksCommand() {
-  const hooksDir = getHooksDir();
-  let removedCount = 0;
-  for (const hookName of HOOK_NAMES) {
-    const hookPath = join(hooksDir, hookName);
-    if (!existsSync(hookPath)) continue;
-    const content = readFileSync(hookPath, "utf-8");
-    if (!content.includes(MARKER)) {
-      console.log(`${hookName}: no mdenc block found (skipped)`);
-      continue;
-    }
-    const lines = content.split("\n");
-    const filtered = [];
-    let inBlock = false;
-    for (const line of lines) {
-      if (line.trim() === MARKER) {
-        inBlock = true;
-        continue;
-      }
-      if (inBlock) {
-        if (line.trim() === "fi") {
-          inBlock = false;
-          continue;
-        }
-        continue;
-      }
-      filtered.push(line);
-    }
-    const result = filtered.join("\n");
-    const isEmpty = result.split("\n").every((l) => l.trim() === "" || l.startsWith("#!"));
-    if (isEmpty) {
-      unlinkSync(hookPath);
-      console.log(`Removed ${hookName} hook (was mdenc-only)`);
-    } else {
-      writeFileSync(hookPath, result);
-      console.log(`Removed mdenc block from ${hookName} hook`);
+function removeFilterCommand() {
+  const repoRoot = findGitRoot();
+  for (const section of ["filter.mdenc", "diff.mdenc"]) {
+    try {
+      execFileSync3("git", ["config", "--local", "--remove-section", section], {
+        cwd: repoRoot,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
     }
-    removedCount++;
-  }
-  if (removedCount === 0) {
-    console.log("No mdenc hooks found to remove.");
-  } else {
-    console.log("mdenc hooks removed.");
   }
+  console.log("Removed git filter configuration.");
 }
 
 // src/git/mark.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2, relative, resolve } from "path";
-var MARKER_FILE = ".mdenc.conf";
+import { execFileSync as execFileSync4 } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6, relative, resolve } from "path";
+var MARKER_FILE2 = ".mdenc.conf";
 var MARKER_CONTENT = "# mdenc: .md files in this directory are automatically encrypted\n";
-var GITIGNORE_PATTERN = "*.md";
+var GITATTR_PATTERN = "*.md filter=mdenc diff=mdenc";
+function isFilterConfigured2(repoRoot) {
+  try {
+    const val = execFileSync4("git", ["config", "--get", "filter.mdenc.process"], {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return val.length > 0;
+  } catch {
+    return false;
+  }
+}
+function markUsage() {
+  console.error(`Usage: mdenc mark <directory>
+
+Mark a directory so that all *.md files inside it are automatically
+encrypted when staged (git add) and decrypted when checked out.
+
+What it does:
+  1. Creates <directory>/.mdenc.conf       Marker file for mdenc to discover
+  2. Creates <directory>/.gitattributes    Assigns the mdenc filter to *.md files
+  3. Stages both files in git
+
+Prerequisites:
+  Run "mdenc init" first to configure the git filter in this clone.
+  Run "mdenc genpass" to generate a password (or set MDENC_PASSWORD).
+
+Example:
+  mdenc init
+  mdenc genpass
+  mdenc mark docs/private
+  echo "# Secret" > docs/private/notes.md
+  git add docs/private/notes.md   # encrypted automatically`);
+  process.exit(1);
+}
 function markCommand(dirArg) {
+  if (dirArg === "--help" || dirArg === "-h") {
+    markUsage();
+  }
   const repoRoot = findGitRoot();
   const dir = resolve(dirArg);
-  if (!existsSync2(dir)) {
+  if (!existsSync3(dir)) {
     console.error(`Error: directory "${dirArg}" does not exist`);
     process.exit(1);
   }
@@ -249,54 +960,62 @@ function markCommand(dirArg) {
     process.exit(1);
   }
   const relDir = rel || ".";
-  const confPath = join2(dir, MARKER_FILE);
-  if (!existsSync2(confPath)) {
-    writeFileSync2(confPath, MARKER_CONTENT);
-    console.log(`Created ${relDir}/${MARKER_FILE}`);
+  const filterReady = isFilterConfigured2(repoRoot);
+  const confPath = join6(dir, MARKER_FILE2);
+  if (!existsSync3(confPath)) {
+    writeFileSync4(confPath, MARKER_CONTENT);
+    console.log(`Created ${relDir}/${MARKER_FILE2}`);
   } else {
-    console.log(`${relDir}/${MARKER_FILE} already exists (skipped)`);
+    console.log(`${relDir}/${MARKER_FILE2} already exists (skipped)`);
   }
-  const gitignorePath = join2(dir, ".gitignore");
-  if (existsSync2(gitignorePath)) {
-    const content = readFileSync2(gitignorePath, "utf-8");
-    const lines = content.split("\n").map((l) => l.trim());
-    if (!lines.includes(GITIGNORE_PATTERN)) {
-      writeFileSync2(gitignorePath, content.trimEnd() + "\n" + GITIGNORE_PATTERN + "\n");
-      console.log(`Updated ${relDir}/.gitignore (added ${GITIGNORE_PATTERN})`);
+  const gitattrsPath = join6(dir, ".gitattributes");
+  if (existsSync3(gitattrsPath)) {
+    const content = readFileSync4(gitattrsPath, "utf-8");
+    if (content.includes("filter=mdenc")) {
+      console.log(`${relDir}/.gitattributes already has filter=mdenc (skipped)`);
     } else {
-      console.log(`${relDir}/.gitignore already has ${GITIGNORE_PATTERN} (skipped)`);
+      writeFileSync4(gitattrsPath, `${content.trimEnd()}
+${GITATTR_PATTERN}
+`);
+      console.log(`Updated ${relDir}/.gitattributes`);
     }
   } else {
-    writeFileSync2(gitignorePath, GITIGNORE_PATTERN + "\n");
-    console.log(`Created ${relDir}/.gitignore with ${GITIGNORE_PATTERN}`);
-  }
-  const mdFiles = getMdFilesInDir(dir);
-  const trackedMd = [];
-  for (const f of mdFiles) {
-    const relPath = relative(repoRoot, join2(dir, f));
-    if (isFileTracked(repoRoot, relPath)) {
-      trackedMd.push(relPath);
-    }
-  }
-  if (trackedMd.length > 0) {
-    gitRmCached(repoRoot, trackedMd);
-    for (const f of trackedMd) {
-      console.log(`Untracked ${f} from git (still exists locally)`);
-    }
+    writeFileSync4(gitattrsPath, `${GITATTR_PATTERN}
+`);
+    console.log(`Created ${relDir}/.gitattributes`);
   }
-  const toStage = [
-    relative(repoRoot, confPath),
-    relative(repoRoot, gitignorePath)
-  ];
+  const toStage = [relative(repoRoot, confPath), relative(repoRoot, gitattrsPath)];
   gitAdd(repoRoot, toStage);
   console.log(`Marked ${relDir}/ for mdenc encryption`);
+  if (!filterReady) {
+    console.log(`
+Warning: git filter not configured yet. Run "mdenc init" to enable encryption.`);
+  }
 }
 
 // src/git/status.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, statSync } from "fs";
-import { join as join3, relative as relative2 } from "path";
-var HOOK_NAMES2 = ["pre-commit", "post-checkout", "post-merge", "post-rewrite"];
-var MARKER2 = "# mdenc-hook-marker";
+import { execFileSync as execFileSync5 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join7, relative as relative2 } from "path";
+function getFilterConfig(repoRoot) {
+  const get = (key) => {
+    try {
+      return execFileSync5("git", ["config", "--get", key], {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch {
+      return null;
+    }
+  };
+  return {
+    process: get("filter.mdenc.process"),
+    clean: get("filter.mdenc.clean"),
+    smudge: get("filter.mdenc.smudge"),
+    required: get("filter.mdenc.required") === "true"
+  };
+}
 function statusCommand() {
   const repoRoot = findGitRoot();
   const password = resolvePassword(repoRoot);
@@ -310,36 +1029,24 @@ function statusCommand() {
       const relDir = relative2(repoRoot, dir) || ".";
       console.log(`  ${relDir}/`);
       const mdFiles = getMdFilesInDir(dir);
-      const mdencFiles = getMdencFilesInDir(dir);
-      const mdBases = new Set(mdFiles.map((f) => f.replace(/\.md$/, "")));
-      const mdencBases = new Set(mdencFiles.map((f) => f.replace(/\.mdenc$/, "")));
-      for (const base of mdBases) {
-        if (mdencBases.has(base)) {
-          const mdPath = join3(dir, `${base}.md`);
-          const mdencPath = join3(dir, `${base}.mdenc`);
-          const mdMtime = statSync(mdPath).mtimeMs;
-          const mdencMtime = statSync(mdencPath).mtimeMs;
-          if (mdMtime > mdencMtime) {
-            console.log(`    ${base}.md  [needs re-encryption]`);
-          } else {
-            console.log(`    ${base}.md  [up to date]`);
-          }
+      for (const f of mdFiles) {
+        const content = readFileSync5(join7(dir, f), "utf-8");
+        if (content.startsWith("mdenc:v1")) {
+          console.log(`    ${f}  [encrypted \u2014 needs smudge]`);
         } else {
-          console.log(`    ${base}.md  [not yet encrypted]`);
+          console.log(`    ${f}  [plaintext]`);
         }
       }
-      for (const base of mdencBases) {
-        if (!mdBases.has(base)) {
-          console.log(`    ${base}.mdenc  [needs decryption]`);
-        }
+      if (mdFiles.length === 0) {
+        console.log("    (no .md files)");
       }
-      const gitignorePath = join3(dir, ".gitignore");
-      if (!existsSync3(gitignorePath)) {
-        console.log(`    WARNING: no .gitignore in this directory`);
+      const gitattrsPath = join7(dir, ".gitattributes");
+      if (!existsSync4(gitattrsPath)) {
+        console.log("    WARNING: no .gitattributes in this directory");
       } else {
-        const content = readFileSync3(gitignorePath, "utf-8");
-        if (!content.split("\n").some((l) => l.trim() === "*.md")) {
-          console.log(`    WARNING: .gitignore missing *.md pattern`);
+        const content = readFileSync5(gitattrsPath, "utf-8");
+        if (!content.includes("filter=mdenc")) {
+          console.log("    WARNING: .gitattributes missing filter=mdenc pattern");
         }
       }
       console.log();
@@ -351,127 +1058,37 @@ function statusCommand() {
   } else {
     console.log("Password: available");
   }
-  const hooksDir = getHooksDir();
-  const missing = [];
-  for (const name of HOOK_NAMES2) {
-    const hookPath = join3(hooksDir, name);
-    if (!existsSync3(hookPath)) {
-      missing.push(name);
-    } else {
-      const content = readFileSync3(hookPath, "utf-8");
-      if (!content.includes(MARKER2)) {
-        missing.push(name);
-      }
-    }
-  }
-  if (missing.length > 0) {
-    console.log(`Hooks: MISSING (${missing.join(", ")})`);
-    console.log('  Run "mdenc init" to install hooks');
+  const config = getFilterConfig(repoRoot);
+  if (!config.process && !config.clean) {
+    console.log("Filter: NOT CONFIGURED");
+    console.log('  Run "mdenc init" to configure');
   } else {
-    console.log("Hooks: all installed");
+    console.log("Filter: configured");
+    if (!config.required) {
+      console.log("  WARNING: filter.mdenc.required is not set to true");
+    }
   }
 }
 
-// src/git/watch.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "fs";
-import { join as join4, relative as relative3 } from "path";
-import { watch } from "chokidar";
-async function watchCommand() {
+// src/git/textconv.ts
+import { readFileSync as readFileSync6 } from "fs";
+async function textconvCommand(filePath) {
+  const content = readFileSync6(filePath, "utf-8");
+  if (!content.startsWith("mdenc:v1")) {
+    process.stdout.write(content);
+    return;
+  }
   const repoRoot = findGitRoot();
   const password = resolvePassword(repoRoot);
   if (!password) {
-    console.error(
-      "mdenc: no password available (set MDENC_PASSWORD or create .mdenc-password)"
-    );
-    process.exit(1);
+    process.stdout.write(content);
+    return;
   }
-  const markedDirs = findMarkedDirs(repoRoot);
-  if (markedDirs.length === 0) {
-    console.error("mdenc: no marked directories found");
-    process.exit(1);
-  }
-  for (const dir of markedDirs) {
-    const mdFiles = getMdFilesInDir(dir);
-    for (const mdFile of mdFiles) {
-      await encryptFile(dir, mdFile, repoRoot, password);
-    }
-  }
-  const pending = /* @__PURE__ */ new Set();
-  const watcher = watch(
-    markedDirs.map((dir) => join4(dir, "*.md")),
-    { ignoreInitial: true, awaitWriteFinish: { stabilityThreshold: 100 } }
-  );
-  watcher.on("change", (filePath) => {
-    handleFileEvent(filePath, repoRoot, password, pending);
-  });
-  watcher.on("add", (filePath) => {
-    handleFileEvent(filePath, repoRoot, password, pending);
-  });
-  for (const dir of markedDirs) {
-    const relDir = relative3(repoRoot, dir) || ".";
-    console.error(`mdenc: watching ${relDir}/`);
-  }
-  console.error("mdenc: watching for changes (Ctrl+C to stop)");
-}
-function handleFileEvent(filePath, repoRoot, password, pending) {
-  if (pending.has(filePath)) return;
-  pending.add(filePath);
-  const dir = join4(filePath, "..");
-  const filename = filePath.slice(dir.length + 1);
-  encryptFile(dir, filename, repoRoot, password).finally(() => {
-    pending.delete(filePath);
-  });
-}
-async function encryptFile(dir, mdFile, repoRoot, password) {
-  const mdPath = join4(dir, mdFile);
-  const mdencPath = mdPath.replace(/\.md$/, ".mdenc");
-  const relMdPath = relative3(repoRoot, mdPath);
-  if (!existsSync4(mdPath)) return;
   try {
-    const plaintext = readFileSync4(mdPath, "utf-8");
-    let previousFile;
-    if (existsSync4(mdencPath)) {
-      previousFile = readFileSync4(mdencPath, "utf-8");
-    }
-    const encrypted = await encrypt(plaintext, password, { previousFile });
-    if (encrypted === previousFile) return;
-    writeFileSync3(mdencPath, encrypted);
-    console.error(`mdenc: encrypted ${relMdPath}`);
-  } catch (err) {
-    console.error(
-      `mdenc: failed to encrypt ${relMdPath}: ${err instanceof Error ? err.message : err}`
-    );
-  }
-}
-
-// src/git/genpass.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join5 } from "path";
-import { randomBytes } from "@noble/ciphers/webcrypto";
-var PASSWORD_FILE = ".mdenc-password";
-function genpassCommand(force) {
-  const repoRoot = findGitRoot();
-  const passwordPath = join5(repoRoot, PASSWORD_FILE);
-  if (existsSync5(passwordPath) && !force) {
-    console.error(`${PASSWORD_FILE} already exists. Use --force to overwrite.`);
-    process.exit(1);
-  }
-  const password = Buffer.from(randomBytes(32)).toString("base64url");
-  writeFileSync4(passwordPath, password + "\n", { mode: 384 });
-  console.error(`Generated password and wrote to ${PASSWORD_FILE}`);
-  console.error(password);
-  const gitignorePath = join5(repoRoot, ".gitignore");
-  const entry = PASSWORD_FILE;
-  if (existsSync5(gitignorePath)) {
-    const content = readFileSync5(gitignorePath, "utf-8");
-    const lines = content.split("\n").map((l) => l.trim());
-    if (!lines.includes(entry)) {
-      writeFileSync4(gitignorePath, content.trimEnd() + "\n" + entry + "\n");
-      console.error("Added .mdenc-password to .gitignore");
-    }
-  } else {
-    writeFileSync4(gitignorePath, entry + "\n");
-    console.error("Created .gitignore with .mdenc-password");
+    const plaintext = await decrypt(content, password);
+    process.stdout.write(plaintext);
+  } catch {
+    process.stdout.write(content);
   }
 }
 
@@ -544,25 +1161,39 @@ async function getPasswordWithConfirmation() {
   }
   return password;
 }
-function usage() {
-  console.error(`Usage:
+var USAGE = `Usage:
   mdenc encrypt <file> [-o output]    Encrypt a markdown file
   mdenc decrypt <file> [-o output]    Decrypt an mdenc file
   mdenc verify <file>                 Verify file integrity
 
 Git integration:
-  mdenc init                          Set up git hooks for automatic encryption
+  mdenc init                          Set up git filter for automatic encryption
   mdenc mark <directory>              Mark a directory for encryption
   mdenc status                        Show encryption status
-  mdenc watch                         Watch and encrypt on file changes
-  mdenc remove-hooks                  Remove mdenc git hooks
-  mdenc genpass [--force]             Generate a random password into .mdenc-password`);
-  process.exit(1);
+  mdenc remove-filter                 Remove git filter configuration
+  mdenc genpass [--force]             Generate a random password into .mdenc-password
+
+Internal (called by git):
+  mdenc filter-process                Long-running filter process
+  mdenc filter-clean <path>           Single-file clean filter
+  mdenc filter-smudge <path>          Single-file smudge filter
+  mdenc textconv <file>               Output plaintext for git diff
+  mdenc diff-driver <path> ...        Custom diff driver (encrypted + plaintext)`;
+function usage(exitCode = 1) {
+  console.error(USAGE);
+  process.exit(exitCode);
 }
 async function main() {
   const args = process.argv.slice(2);
   if (args.length === 0) usage();
   const command = args[0];
+  if (command === "--help" || command === "-h") usage(0);
+  if (command === "--version" || command === "-v") {
+    const pkgPath = new URL("../package.json", import.meta.url);
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+    console.log(pkg.version);
+    return;
+  }
   try {
     switch (command) {
       case "encrypt": {
@@ -571,7 +1202,7 @@ async function main() {
         const outputIdx = args.indexOf("-o");
         const outputFile = outputIdx >= 0 ? args[outputIdx + 1] : void 0;
         const password = await getPasswordWithConfirmation();
-        const plaintext = readFileSync6(inputFile, "utf-8");
+        const plaintext = readFileSync7(inputFile, "utf-8");
         const encrypted = await encrypt(plaintext, password);
         if (outputFile) {
           writeFileSync5(outputFile, encrypted);
@@ -586,7 +1217,7 @@ async function main() {
         const outputIdx = args.indexOf("-o");
         const outputFile = outputIdx >= 0 ? args[outputIdx + 1] : void 0;
         const password = await getPassword();
-        const fileContent = readFileSync6(inputFile, "utf-8");
+        const fileContent = readFileSync7(inputFile, "utf-8");
         const decrypted = await decrypt(fileContent, password);
         if (outputFile) {
           writeFileSync5(outputFile, decrypted);
@@ -599,7 +1230,7 @@ async function main() {
         if (!args[1]) usage();
         const inputFile = args[1];
         const password = await getPassword();
-        const fileContent = readFileSync6(inputFile, "utf-8");
+        const fileContent = readFileSync7(inputFile, "utf-8");
         const valid = await verifySeal(fileContent, password);
         if (valid) {
           console.error("Seal verified: OK");
@@ -615,7 +1246,7 @@ async function main() {
         break;
       case "mark": {
         if (!args[1]) {
-          console.error("Usage: mdenc mark <directory>");
+          console.error('Usage: mdenc mark <directory>\n\nRun "mdenc mark --help" for details.');
           process.exit(1);
         }
         markCommand(args[1]);
@@ -624,27 +1255,31 @@ async function main() {
       case "status":
         statusCommand();
         break;
-      case "watch":
-        await watchCommand();
-        break;
-      case "remove-hooks":
-        removeHooksCommand();
+      case "remove-filter":
+        removeFilterCommand();
         break;
       case "genpass":
         genpassCommand(args.includes("--force"));
         break;
-      // Git hook handlers (called by hook scripts, not directly by user)
-      case "pre-commit":
-        await preCommitHook();
+      // Git filter commands (called by git, not directly by user)
+      case "filter-process":
+        await filterProcessMain();
         break;
-      case "post-checkout":
-        await postCheckoutHook();
+      case "filter-clean":
+        await simpleCleanFilter(args[1] ?? "");
         break;
-      case "post-merge":
-        await postMergeHook();
+      case "filter-smudge":
+        await simpleSmudgeFilter();
         break;
-      case "post-rewrite":
-        await postRewriteHook();
+      case "diff-driver":
+        await diffDriverCommand(args.slice(1));
+        break;
+      case "textconv":
+        if (!args[1]) {
+          console.error("Usage: mdenc textconv <file>");
+          process.exit(1);
+        }
+        await textconvCommand(args[1]);
         break;
       default:
         console.error(`Unknown command: ${command}`);