mdmeld 0.1.0

package/dist/core/index.cjs

@@ -0,0 +1,609 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  check: () => check,
+  pack: () => pack,
+  unpack: () => unpack
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/core/constants.ts
+var FORMAT_VERSION = "1.0.0";
+var MIN_BACKTICK_COUNT = 4;
+var MAX_BACKTICK_COUNT = 8;
+var HASH_PLACEHOLDER = "HASH_PLACEHOLDER";
+var ARCHIVE_HEADER = `<!-- MDMeld v1.0 archive \u2014 a directory tree encoded as markdown.
+     Read the manifest below for file listing and positions.
+     Spec: https://github.com/3leaps/mdmeld -->`;
+
+// src/core/backticks.ts
+function scanForMaxBackticks(content) {
+  let max = 0;
+  let current = 0;
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "`") {
+      current++;
+      if (current > max) max = current;
+    } else {
+      current = 0;
+    }
+  }
+  return max;
+}
+function resolveBacktickCount(maxFoundInContent) {
+  const needed = Math.max(maxFoundInContent + 1, MIN_BACKTICK_COUNT);
+  if (needed > MAX_BACKTICK_COUNT) return null;
+  return needed;
+}
+function generateBackticks(count) {
+  return "`".repeat(count);
+}
+
+// src/core/base64.ts
+var CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function encodeBase64(data) {
+  let result = "";
+  const len = data.length;
+  const remainder = len % 3;
+  const mainLen = len - remainder;
+  for (let i = 0; i < mainLen; i += 3) {
+    const a = data[i];
+    const b = data[i + 1];
+    const c = data[i + 2];
+    result += CHARS[a >> 2];
+    result += CHARS[(a & 3) << 4 | b >> 4];
+    result += CHARS[(b & 15) << 2 | c >> 6];
+    result += CHARS[c & 63];
+  }
+  if (remainder === 1) {
+    const a = data[mainLen];
+    result += `${CHARS[a >> 2]}${CHARS[(a & 3) << 4]}==`;
+  } else if (remainder === 2) {
+    const a = data[mainLen];
+    const b = data[mainLen + 1];
+    result += `${CHARS[a >> 2]}${CHARS[(a & 3) << 4 | b >> 4]}${CHARS[(b & 15) << 2]}=`;
+  }
+  return result;
+}
+var DECODE_TABLE = new Uint8Array(128);
+for (let i = 0; i < CHARS.length; i++) {
+  DECODE_TABLE[CHARS.charCodeAt(i)] = i;
+}
+function decodeBase64(base64) {
+  const str = base64.replace(/\s/g, "");
+  const len = str.length;
+  let padding = 0;
+  if (str[len - 1] === "=") padding++;
+  if (str[len - 2] === "=") padding++;
+  const byteLen = len * 3 / 4 - padding;
+  const result = new Uint8Array(byteLen);
+  let j = 0;
+  for (let i = 0; i < len; i += 4) {
+    const a = DECODE_TABLE[str.charCodeAt(i)];
+    const b = DECODE_TABLE[str.charCodeAt(i + 1)];
+    const c = DECODE_TABLE[str.charCodeAt(i + 2)];
+    const d = DECODE_TABLE[str.charCodeAt(i + 3)];
+    result[j++] = a << 2 | b >> 4;
+    if (j < byteLen) result[j++] = (b & 15) << 4 | c >> 2;
+    if (j < byteLen) result[j++] = (c & 3) << 6 | d;
+  }
+  return result;
+}
+
+// src/core/detect.ts
+function isText(data) {
+  if (data.length === 0) return true;
+  const sample = data.length > 8192 ? data.subarray(0, 8192) : data;
+  const len = sample.length;
+  let nullBytes = 0;
+  let controlChars = 0;
+  let printableOrWhitespace = 0;
+  for (let i = 0; i < len; i++) {
+    const byte = sample[i];
+    if (byte === 0) {
+      nullBytes++;
+    } else if (byte === 9 || byte === 10 || byte === 13) {
+      printableOrWhitespace++;
+    } else if (byte < 32) {
+      controlChars++;
+    } else if (byte <= 126) {
+      printableOrWhitespace++;
+    }
+  }
+  if (nullBytes > 0) return false;
+  if (controlChars / len > 0.05) return false;
+  if (len > 32 && printableOrWhitespace / len < 0.8) return false;
+  return true;
+}
+
+// src/core/hash.ts
+var import_xxhash_wasm = __toESM(require("xxhash-wasm"), 1);
+async function sha256(data) {
+  if (typeof globalThis.crypto?.subtle !== "undefined") {
+    return globalThis.crypto.subtle.digest("SHA-256", data);
+  }
+  const { webcrypto } = await import("crypto");
+  return webcrypto.subtle.digest("SHA-256", data);
+}
+var xxhashInstance = null;
+async function getXxhash() {
+  if (!xxhashInstance) {
+    xxhashInstance = await (0, import_xxhash_wasm.default)();
+  }
+  return xxhashInstance;
+}
+async function computeHash(content, algorithm) {
+  if (algorithm === "xxh64") {
+    const xxhash = await getXxhash();
+    return xxhash.h64ToString(content);
+  }
+  const encoder = new TextEncoder();
+  const data = encoder.encode(content);
+  const hashBuffer = await sha256(data);
+  const hashArray = new Uint8Array(hashBuffer);
+  return Array.from(hashArray).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function computeHashBytes(data, algorithm) {
+  if (algorithm === "xxh64") {
+    const xxhash = await getXxhash();
+    const raw = xxhash.h64Raw(data);
+    return raw.toString(16).padStart(16, "0");
+  }
+  const hashBuffer = await sha256(data);
+  const hashArray = new Uint8Array(hashBuffer);
+  return Array.from(hashArray).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/core/syntax.ts
+var EXT_TO_SYNTAX = {
+  // Web
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "jsx",
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".astro": "astro",
+  // Data
+  ".json": "json",
+  ".jsonc": "jsonc",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".xml": "xml",
+  ".csv": "csv",
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  // Config
+  ".env": "dotenv",
+  ".ini": "ini",
+  ".conf": "conf",
+  ".cfg": "ini",
+  // Shell
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "zsh",
+  ".fish": "fish",
+  ".ps1": "powershell",
+  ".bat": "batch",
+  ".cmd": "batch",
+  // Systems
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".rs": "rust",
+  ".go": "go",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".swift": "swift",
+  ".cs": "csharp",
+  ".fs": "fsharp",
+  ".zig": "zig",
+  // Scripting
+  ".py": "python",
+  ".rb": "ruby",
+  ".php": "php",
+  ".pl": "perl",
+  ".lua": "lua",
+  ".r": "r",
+  ".R": "r",
+  ".jl": "julia",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".clj": "clojure",
+  ".scala": "scala",
+  ".dart": "dart",
+  // Markup / Docs
+  ".md": "markdown",
+  ".mdx": "mdx",
+  ".rst": "rst",
+  ".tex": "latex",
+  ".typ": "typst",
+  // DevOps
+  ".dockerfile": "dockerfile",
+  ".tf": "terraform",
+  ".hcl": "hcl",
+  ".nix": "nix",
+  // SQL
+  ".sql": "sql",
+  // Misc
+  ".diff": "diff",
+  ".patch": "diff",
+  ".prisma": "prisma",
+  ".proto": "protobuf",
+  ".wasm": "wasm",
+  ".lock": "text",
+  ".log": "text",
+  ".txt": "text"
+};
+var NAME_TO_SYNTAX = {
+  Dockerfile: "dockerfile",
+  Makefile: "makefile",
+  Containerfile: "dockerfile",
+  Justfile: "makefile",
+  Vagrantfile: "ruby",
+  Gemfile: "ruby",
+  Rakefile: "ruby",
+  ".gitignore": "gitignore",
+  ".gitattributes": "gitattributes",
+  ".editorconfig": "editorconfig",
+  ".prettierrc": "json",
+  ".eslintrc": "json"
+};
+function getSyntax(filePath) {
+  const fileName = filePath.split("/").pop() ?? "";
+  const byName = NAME_TO_SYNTAX[fileName];
+  if (byName) return byName;
+  const dotIdx = fileName.lastIndexOf(".");
+  if (dotIdx === -1) return "text";
+  const ext = fileName.slice(dotIdx).toLowerCase();
+  return EXT_TO_SYNTAX[ext] ?? "text";
+}
+
+// src/core/yaml.ts
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+function dump(value) {
+  return import_js_yaml.default.dump(value, {
+    lineWidth: -1,
+    noRefs: true,
+    quotingType: '"',
+    forceQuotes: false
+  });
+}
+function load(text) {
+  return import_js_yaml.default.load(text);
+}
+
+// src/core/pack.ts
+var TEXT_DECODER = new TextDecoder();
+async function pack(files, options = {}) {
+  const hashAlgorithm = options.hashAlgorithm ?? "xxh64";
+  const created = options.created ?? (/* @__PURE__ */ new Date()).toISOString();
+  let maxBackticks = 0;
+  const fileInfos = [];
+  for (const file of files) {
+    const textFile = isText(file.content);
+    if (textFile) {
+      const text = TEXT_DECODER.decode(file.content);
+      const found = scanForMaxBackticks(text);
+      if (found > maxBackticks) maxBackticks = found;
+      fileInfos.push({ file, isTextFile: true, textContent: text, base64Content: null });
+    } else {
+      const b64 = encodeBase64(file.content);
+      fileInfos.push({ file, isTextFile: false, textContent: null, base64Content: b64 });
+    }
+  }
+  const backtickCount = resolveBacktickCount(maxBackticks);
+  if (backtickCount === null) {
+    throw new Error(
+      "Cannot pack: file content contains a backtick run of 8 or more characters, which exceeds the maximum allowed fence width. Remove the excessive backtick sequences or exclude the file."
+    );
+  }
+  const fence = generateBackticks(backtickCount);
+  const contentBlocks = [];
+  const fileEntries = [];
+  for (const info of fileInfos) {
+    const path = info.file.path;
+    let contentStr;
+    let fenceLang;
+    let type;
+    let syntax;
+    let encoding;
+    const hash = await computeHashBytes(info.file.content, hashAlgorithm);
+    if (info.textContent !== null) {
+      contentStr = info.textContent;
+      type = "text";
+      syntax = getSyntax(path);
+      fenceLang = syntax;
+      encoding = void 0;
+    } else {
+      const b64 = info.base64Content;
+      contentStr = b64;
+      type = info.isTextFile ? "text" : "binary";
+      syntax = getSyntax(path);
+      fenceLang = "base64";
+      encoding = "base64";
+    }
+    const block = `### ${path}
+
+${fence}${fenceLang}
+${contentStr}
+${fence}`;
+    contentBlocks.push(block);
+    fileEntries.push({
+      path,
+      type,
+      size: info.file.content.length,
+      hash,
+      syntax,
+      ...encoding ? { encoding } : {},
+      position: { start: 0, fence: 0, content: 0, length: 0 }
+      // placeholder
+    });
+  }
+  const contentSection = contentBlocks.join("\n\n");
+  const manifest = {
+    mdmeld: {
+      version: FORMAT_VERSION,
+      created,
+      hash_algorithm: hashAlgorithm,
+      backtick_count: backtickCount,
+      files: fileEntries
+    },
+    integrity: {
+      manifest_hash: HASH_PLACEHOLDER,
+      content_hash: HASH_PLACEHOLDER
+    }
+  };
+  const entriesNoPos = fileEntries.map((f) => {
+    const { position: _, ...rest } = f;
+    return rest;
+  });
+  const prelimYaml = dump({
+    ...manifest,
+    mdmeld: { ...manifest.mdmeld, files: entriesNoPos }
+  });
+  const prelimFrontmatter = `${ARCHIVE_HEADER}
+---
+${prelimYaml}---
+`;
+  const prelimLines = countLines(prelimFrontmatter);
+  const positions1 = calculatePositions(contentSection, prelimLines);
+  applyPositions(fileEntries, positions1);
+  const withPosYaml = dump(manifest);
+  const withPosFrontmatter = `${ARCHIVE_HEADER}
+---
+${withPosYaml}---
+`;
+  const finalLines = countLines(withPosFrontmatter);
+  if (finalLines !== prelimLines) {
+    const positions2 = calculatePositions(contentSection, finalLines);
+    applyPositions(fileEntries, positions2);
+  }
+  const rawContentForHash = `
+
+${contentSection}`;
+  const contentHash = await computeHash(rawContentForHash, hashAlgorithm);
+  manifest.integrity.content_hash = contentHash;
+  const manifestYamlForHash = dump({ mdmeld: manifest.mdmeld });
+  const manifestHash = await computeHash(manifestYamlForHash, hashAlgorithm);
+  manifest.integrity.manifest_hash = manifestHash;
+  const outputYaml = dump(manifest);
+  return `${ARCHIVE_HEADER}
+---
+${outputYaml}---
+
+${contentSection}`;
+}
+function calculatePositions(contentSection, manifestLineCount) {
+  const lines = contentSection.split("\n");
+  const positions = [];
+  const offset = manifestLineCount + 1;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.startsWith("### ")) {
+      const start = offset + i + 1;
+      i++;
+      if (i < lines.length && lines[i].trim() === "") {
+        i++;
+      }
+      if (i < lines.length && isFenceLine(lines[i])) {
+        const fenceLine = offset + i + 1;
+        i++;
+        const contentStart = offset + i + 1;
+        let contentLength = 0;
+        while (i < lines.length && !isFenceLine(lines[i])) {
+          contentLength++;
+          i++;
+        }
+        if (i < lines.length) i++;
+        positions.push({
+          start,
+          fence: fenceLine,
+          content: contentStart,
+          length: contentLength
+        });
+      }
+    } else {
+      i++;
+    }
+  }
+  return positions;
+}
+function applyPositions(entries, positions) {
+  for (let i = 0; i < entries.length; i++) {
+    entries[i].position = positions[i];
+  }
+}
+function countLines(s) {
+  if (s.length === 0) return 0;
+  let count = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\n") count++;
+  }
+  if (s[s.length - 1] !== "\n") count++;
+  return count;
+}
+function isFenceLine(line) {
+  return /^`{4,}/.test(line.trim());
+}
+
+// src/core/unpack.ts
+var TEXT_ENCODER = new TextEncoder();
+async function unpack(content) {
+  const { manifest, contentSection } = parseArchive(content);
+  const files = extractFiles(contentSection, manifest);
+  return { files, manifest };
+}
+async function check(content) {
+  const errors = [];
+  let manifest;
+  let contentSection;
+  let rawContentAfterDelimiter;
+  try {
+    const parsed = parseArchive(content);
+    manifest = parsed.manifest;
+    contentSection = parsed.contentSection;
+    rawContentAfterDelimiter = parsed.rawContentAfterDelimiter;
+  } catch (e) {
+    return { valid: false, errors: [`Parse error: ${e.message}`] };
+  }
+  const algorithm = manifest.mdmeld.hash_algorithm;
+  if (manifest.integrity.content_hash !== HASH_PLACEHOLDER && manifest.integrity.content_hash !== "") {
+    const actual = await computeHash(rawContentAfterDelimiter, algorithm);
+    if (actual !== manifest.integrity.content_hash) {
+      errors.push(
+        `Content hash mismatch: expected ${manifest.integrity.content_hash}, got ${actual}`
+      );
+    }
+  }
+  if (manifest.integrity.manifest_hash !== HASH_PLACEHOLDER && manifest.integrity.manifest_hash !== "") {
+    const manifestYaml = dump({ mdmeld: manifest.mdmeld });
+    const actual = await computeHash(manifestYaml, algorithm);
+    if (actual !== manifest.integrity.manifest_hash) {
+      errors.push(
+        `Manifest hash mismatch: expected ${manifest.integrity.manifest_hash}, got ${actual}`
+      );
+    }
+  }
+  const files = extractFiles(contentSection, manifest);
+  for (let i = 0; i < manifest.mdmeld.files.length; i++) {
+    const entry = manifest.mdmeld.files[i];
+    const file = files[i];
+    if (!file) {
+      errors.push(`Missing content block for file: ${entry.path}`);
+      continue;
+    }
+    if (entry.hash === HASH_PLACEHOLDER) continue;
+    const actual = await computeHashBytes(file.content, algorithm);
+    if (actual !== entry.hash) {
+      errors.push(`File hash mismatch for ${entry.path}: expected ${entry.hash}, got ${actual}`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function parseArchive(content) {
+  let input = content;
+  if (input.startsWith("<!--")) {
+    const commentEnd = input.indexOf("-->");
+    if (commentEnd !== -1) {
+      input = input.slice(commentEnd + 3).trimStart();
+    }
+  }
+  if (!input.startsWith("---")) {
+    throw new Error("Missing YAML frontmatter (expected --- delimiter)");
+  }
+  const secondDelim = input.indexOf("\n---", 3);
+  if (secondDelim === -1) {
+    throw new Error("Missing closing --- delimiter for YAML frontmatter");
+  }
+  const yamlStr = input.slice(4, secondDelim);
+  const rawContentAfterDelimiter = input.slice(secondDelim + 4);
+  const contentSection = rawContentAfterDelimiter.replace(/^\n+/, "");
+  const parsed = load(yamlStr);
+  if (!parsed || typeof parsed !== "object" || !("mdmeld" in parsed)) {
+    throw new Error("Invalid manifest: missing 'mdmeld' key");
+  }
+  const manifest = parsed;
+  const archiveMajor = String(manifest.mdmeld.version).split(".")[0];
+  const supportedMajor = FORMAT_VERSION.split(".")[0];
+  if (archiveMajor !== supportedMajor) {
+    throw new Error(
+      `Unsupported archive version: ${manifest.mdmeld.version} (this parser supports major version ${supportedMajor})`
+    );
+  }
+  return { manifest, contentSection, rawContentAfterDelimiter };
+}
+function extractFiles(contentSection, manifest) {
+  const backtickCount = manifest.mdmeld.backtick_count;
+  const fence = "`".repeat(backtickCount);
+  const files = [];
+  const pattern = new RegExp(
+    `### (.+?)\\s*\\n\\s*${fence}([^\\n]*)\\n([\\s\\S]*?)\\n?${fence}(?=\\s|$)`,
+    "g"
+  );
+  for (const match of contentSection.matchAll(pattern)) {
+    const path = match[1].trim();
+    const lang = match[2].trim();
+    const rawContent = match[3];
+    const entry = manifest.mdmeld.files.find((f) => f.path === path);
+    const isEncoded = lang === "base64" || entry?.encoding === "base64";
+    let content;
+    if (isEncoded) {
+      content = decodeBase64(rawContent);
+    } else {
+      content = TEXT_ENCODER.encode(rawContent);
+    }
+    files.push({ path, content });
+  }
+  return files;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  check,
+  pack,
+  unpack
+});
+//# sourceMappingURL=index.cjs.map