codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/logger.js

@@ -0,0 +1,217 @@
+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);
+var logger_exports = {};
+__export(logger_exports, {
+  LOG_DAILY_CAP_BYTES: () => LOG_DAILY_CAP_BYTES,
+  LOG_RETENTION_DAYS: () => LOG_RETENTION_DAYS,
+  getCurrentLogPath: () => getCurrentLogPath,
+  getLogDir: () => getLogDir,
+  installFileLogger: () => installFileLogger,
+  isWritingLogFile: () => isWritingLogFile,
+  pruneOldLogs: () => pruneOldLogs,
+  setLogRetention: () => setLogRetention,
+  tailLog: () => tailLog
+});
+module.exports = __toCommonJS(logger_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_persistence = require("./persistence");
+let installed = false;
+let logStream = null;
+let currentLogPath = null;
+let currentBytes = 0;
+let capNoticeWritten = false;
+const LOG_RETENTION_DAYS = 14;
+let logRetentionDays = LOG_RETENTION_DAYS;
+function setLogRetention(days) {
+  logRetentionDays = days;
+}
+const LOG_DAILY_CAP_BYTES = 50 * 1024 * 1024;
+function installFileLogger() {
+  if (installed) return;
+  installed = true;
+  try {
+    rotateIfNeeded();
+  } catch (err) {
+    console.warn("[Logger] Failed to open log file \u2014 console only:", err);
+    return;
+  }
+  const origLog = console.log.bind(console);
+  const origWarn = console.warn.bind(console);
+  const origError = console.error.bind(console);
+  const origInfo = console.info.bind(console);
+  const writeLine = (level, args) => {
+    try {
+      rotateIfNeeded();
+      const ts = (/* @__PURE__ */ new Date()).toISOString();
+      const line = `${ts} [${level}] ${formatArgs(args)}
+`;
+      if (currentBytes >= LOG_DAILY_CAP_BYTES) {
+        if (!capNoticeWritten) {
+          capNoticeWritten = true;
+          logStream?.write(`${ts} [warn] [Logger] Daily cap of ${LOG_DAILY_CAP_BYTES} bytes reached; further lines today go to the console only.
+`);
+        }
+        return;
+      }
+      currentBytes += Buffer.byteLength(line);
+      logStream?.write(line);
+    } catch {
+    }
+  };
+  console.log = (...args) => {
+    origLog(...args);
+    writeLine("info", args);
+  };
+  console.info = (...args) => {
+    origInfo(...args);
+    writeLine("info", args);
+  };
+  console.warn = (...args) => {
+    origWarn(...args);
+    writeLine("warn", args);
+  };
+  console.error = (...args) => {
+    origError(...args);
+    writeLine("error", args);
+  };
+  process.on("uncaughtException", (err) => {
+    writeLine("uncaught", [err?.stack || String(err)]);
+  });
+  process.on("unhandledRejection", (reason) => {
+    writeLine("unhandled", [reason instanceof Error ? reason.stack : String(reason)]);
+  });
+  console.log(`[Logger] File logging enabled at ${currentLogPath}`);
+}
+function getCurrentLogPath() {
+  if (!installed) return import_node_path.default.join(logDir(), `${ymd(/* @__PURE__ */ new Date())}.log`);
+  rotateIfNeeded();
+  return currentLogPath || import_node_path.default.join(logDir(), `${ymd(/* @__PURE__ */ new Date())}.log`);
+}
+function isWritingLogFile() {
+  return installed;
+}
+function getLogDir() {
+  return logDir();
+}
+function tailLog(maxBytes = 64 * 1024) {
+  try {
+    const p = getCurrentLogPath();
+    if (!import_node_fs.default.existsSync(p)) return "";
+    const stat = import_node_fs.default.statSync(p);
+    if (stat.size <= maxBytes) {
+      return import_node_fs.default.readFileSync(p, "utf-8");
+    }
+    const fd = import_node_fs.default.openSync(p, "r");
+    try {
+      const buf = Buffer.alloc(maxBytes);
+      import_node_fs.default.readSync(fd, buf, 0, maxBytes, stat.size - maxBytes);
+      const text = buf.toString("utf-8");
+      const firstNewline = text.indexOf("\n");
+      return firstNewline >= 0 ? text.slice(firstNewline + 1) : text;
+    } finally {
+      import_node_fs.default.closeSync(fd);
+    }
+  } catch {
+    return "";
+  }
+}
+function logDir() {
+  return import_node_path.default.join((0, import_persistence.getDataDir)(), "logs");
+}
+function ymd(d) {
+  return d.toISOString().slice(0, 10);
+}
+function rotateIfNeeded() {
+  const targetPath = import_node_path.default.join(logDir(), `${ymd(/* @__PURE__ */ new Date())}.log`);
+  if (currentLogPath === targetPath && logStream) return;
+  if (logStream) {
+    try {
+      logStream.end();
+    } catch {
+    }
+    logStream = null;
+  }
+  if (!import_node_fs.default.existsSync(logDir())) {
+    import_node_fs.default.mkdirSync(logDir(), { recursive: true });
+  }
+  logStream = import_node_fs.default.createWriteStream(targetPath, { flags: "a", encoding: "utf-8" });
+  currentLogPath = targetPath;
+  try {
+    currentBytes = import_node_fs.default.statSync(targetPath).size;
+  } catch {
+    currentBytes = 0;
+  }
+  capNoticeWritten = false;
+  if (logRetentionDays !== null) pruneOldLogs(logDir(), /* @__PURE__ */ new Date(), logRetentionDays);
+}
+function pruneOldLogs(dir, now, keepDays = LOG_RETENTION_DAYS) {
+  const removed = [];
+  const cutoff = new Date(now);
+  cutoff.setUTCDate(cutoff.getUTCDate() - keepDays);
+  const cutoffYmd = ymd(cutoff);
+  let names = [];
+  try {
+    names = import_node_fs.default.readdirSync(dir);
+  } catch {
+    return removed;
+  }
+  for (const name of names) {
+    const m = /^(\d{4}-\d{2}-\d{2})\.log$/.exec(name);
+    if (!m || m[1] >= cutoffYmd) continue;
+    try {
+      import_node_fs.default.unlinkSync(import_node_path.default.join(dir, name));
+      removed.push(name);
+    } catch {
+    }
+  }
+  return removed;
+}
+function formatArgs(args) {
+  return args.map((a) => {
+    if (a instanceof Error) return a.stack || a.message;
+    if (typeof a === "string") return a;
+    try {
+      return JSON.stringify(a);
+    } catch {
+      return String(a);
+    }
+  }).join(" ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOG_DAILY_CAP_BYTES,
+  LOG_RETENTION_DAYS,
+  getCurrentLogPath,
+  getLogDir,
+  installFileLogger,
+  isWritingLogFile,
+  pruneOldLogs,
+  setLogRetention,
+  tailLog
+});

package/src/backend/services/material-footprints.js

@@ -0,0 +1,203 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var material_footprints_exports = {};
+__export(material_footprints_exports, {
+  locatorKey: () => locatorKey,
+  materialInputsOf: () => materialInputsOf,
+  partWords: () => partWords,
+  readSoFar: () => readSoFar,
+  recordMaterialRead: () => recordMaterialRead,
+  taskFootprint: () => taskFootprint
+});
+module.exports = __toCommonJS(material_footprints_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_task_workstreams = require("./task-workstreams");
+function rowsOf(sql, params = []) {
+  const res = (0, import_database.getDb)().exec(sql, params);
+  if (!res.length) return [];
+  const { columns, values } = res[0];
+  return values.map((v) => Object.fromEntries(columns.map((c, i) => [c, v[i]])));
+}
+function locatorKey(locator) {
+  if (!locator) return null;
+  const keys = ["sheet", "range", "page", "lines", "text"].filter((k) => locator[k] !== void 0 && locator[k] !== "");
+  if (!keys.length) return null;
+  return JSON.stringify(Object.fromEntries(keys.map((k) => [k, locator[k]])));
+}
+function recordMaterialRead(input) {
+  const att = rowsOf(
+    "SELECT target_uid, value, sha256 FROM attachments WHERE uid = ?",
+    [input.attachmentUid]
+  )[0];
+  if (!att) return null;
+  const brief = input.sessionId ? rowsOf("SELECT brief_item_uid FROM agent_sessions WHERE session_id = ?", [input.sessionId])[0]?.brief_item_uid ?? null : null;
+  const itemUid = brief ?? att.target_uid;
+  (0, import_database.getDb)().run(
+    "INSERT INTO material_reads (item_uid, session_id, attachment_uid, path, sha256, locator, at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+    [itemUid, input.sessionId, input.attachmentUid, att.value, att.sha256, locatorKey(input.locator), input.at ?? Date.now()]
+  );
+  (0, import_persistence.markDirty)();
+  return itemUid;
+}
+const verifiedOf = (verdict) => {
+  try {
+    return JSON.parse(verdict ?? "{}").verified === true;
+  } catch {
+    return false;
+  }
+};
+const attachmentHere = (uid) => rowsOf("SELECT 1 FROM attachments WHERE uid = ?", [uid]).length > 0;
+const parseLocator = (s) => {
+  if (!s) return null;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+};
+function taskFootprint(itemUid) {
+  const reads = rowsOf(
+    `SELECT * FROM (
+       SELECT r.session_id, s.agent_type, r.attachment_uid, r.path, r.sha256, r.locator, r.at, NULL AS reader, NULL AS name, NULL AS verdict, 0 AS src, r.rowid AS n
+         FROM material_reads r LEFT JOIN agent_sessions s ON s.session_id = r.session_id
+        WHERE r.item_uid = ?
+       UNION ALL
+       SELECT NULL, NULL, t.attachment_uid, t.path, t.sha256, NULL, t.at, t.reader, t.name, t.verdict, 1, t.counter
+         FROM teammate_material_reads t
+        WHERE t.item_uid = ?
+     ) ORDER BY at, src, n`,
+    [itemUid, itemUid]
+  );
+  const byPath = /* @__PURE__ */ new Map();
+  for (const r of reads) {
+    const m = byPath.get(r.path) ?? byPath.set(r.path, { path: r.path, attachmentUid: r.attachment_uid ?? "", reads: [], lastSha256: null, parts: [] }).get(r.path);
+    const locator = parseLocator(r.locator);
+    const teammate = r.reader ? { reader: r.reader, name: r.name ?? "someone", verified: verifiedOf(r.verdict) } : null;
+    const attachmentUid = r.attachment_uid && (!teammate || attachmentHere(r.attachment_uid)) ? r.attachment_uid : m.attachmentUid;
+    m.reads.push({ sessionId: r.session_id, agent: r.agent_type, teammate, attachmentUid, sha256: r.sha256, locator, at: Number(r.at) });
+    m.attachmentUid = attachmentUid;
+    m.lastSha256 = r.sha256;
+    if (r.locator && !m.parts.some((p) => locatorKey(p) === r.locator)) m.parts.push(locator);
+  }
+  const outputs = rowsOf(
+    `SELECT uid, value, sha256 FROM attachments WHERE target_type = 'item' AND target_uid = ? AND role = 'output' ORDER BY created_at`,
+    [itemUid]
+  ).map((r) => ({ attachmentUid: r.uid, path: r.value, sha256: r.sha256 }));
+  const cited = /* @__PURE__ */ new Map();
+  for (const r of rowsOf(
+    `SELECT e.criterion_uid, e.attachment_uid, a.value, a.sha256, e.locator, e.sha256_at_submit AS at_cite,
+            (SELECT s.decision FROM criterion_signoffs s WHERE s.criterion_uid = e.criterion_uid ORDER BY s.created_at DESC, s.rowid DESC LIMIT 1) AS decision
+       FROM criterion_evidence e
+       JOIN item_criteria c ON c.uid = e.criterion_uid
+       JOIN attachments a ON a.uid = e.attachment_uid
+      WHERE c.item_uid = ? AND e.attachment_uid IS NOT NULL
+      ORDER BY e.submitted_at, e.rowid`,
+    [itemUid]
+  )) {
+    const locator = parseLocator(r.locator);
+    const key = `${r.value}
+${locatorKey(locator) ?? ""}`;
+    cited.delete(key);
+    cited.set(key, {
+      attachmentUid: r.attachment_uid,
+      path: r.value,
+      sha256: r.sha256,
+      locator,
+      criterionUid: r.criterion_uid,
+      sha256AtCite: r.at_cite,
+      signedOff: r.decision === "approved"
+    });
+  }
+  return { itemUid, read: [...byPath.values()], outputs, cited: [...cited.values()] };
+}
+function partWords(l) {
+  if (!l) return "the whole file";
+  if (l.sheet || l.range) return l.sheet && l.range ? `${l.sheet}!${l.range}` : l.sheet ?? l.range;
+  if (l.page !== void 0) return /[-–]/.test(String(l.page)) ? `pages ${String(l.page).replace("-", "\u2013")}` : `page ${l.page}`;
+  if (l.lines !== void 0) return /[-–]/.test(String(l.lines)) ? `lines ${String(l.lines).replace("-", "\u2013")}` : `line ${l.lines}`;
+  if (l.text) return `where it says \u201C${l.text.length > 40 ? `${l.text.slice(0, 40)}\u2026` : l.text}\u201D`;
+  return "the whole file";
+}
+function readSoFar(itemUid) {
+  return taskFootprint(itemUid).read.map((m) => ({
+    path: m.path,
+    attachment_uid: m.attachmentUid,
+    reads: m.reads.length,
+    parts: [...new Set(m.reads.map((r) => partWords(r.locator)))],
+    by: [...new Set(m.reads.map((r) => r.teammate ? `${r.teammate.reader}${r.teammate.verified ? "" : " (unverified)"}` : r.agent ?? "an agent"))],
+    sha256: m.lastSha256,
+    last_read_at: new Date(m.reads[m.reads.length - 1].at).toISOString()
+  }));
+}
+function materialInputsOf(projectRoot) {
+  const trimmed = projectRoot.replace(/[\\/]+$/, "");
+  const inProject = `SELECT i.uid FROM plan_items i JOIN plans p ON p.uid = i.plan_uid WHERE p.project_path = ? OR p.project_path = ?`;
+  const uids = rowsOf(
+    `SELECT DISTINCT uid FROM (
+       SELECT item_uid AS uid FROM material_reads
+       UNION SELECT item_uid FROM teammate_material_reads
+       UNION SELECT target_uid FROM attachments WHERE role = 'output'
+       UNION SELECT c.item_uid FROM criterion_evidence e JOIN item_criteria c ON c.uid = e.criterion_uid WHERE e.attachment_uid IS NOT NULL
+     ) WHERE uid IN (${inProject}) ORDER BY uid`,
+    [projectRoot, trimmed]
+  ).map((r) => r.uid);
+  const titleOf = (uid) => rowsOf("SELECT title FROM plan_items WHERE uid = ?", [uid])[0]?.title ?? uid;
+  const ownerOf = (attachmentUid) => rowsOf("SELECT target_uid FROM attachments WHERE uid = ?", [attachmentUid])[0]?.target_uid ?? null;
+  const tasks = uids.map((uid) => {
+    const f = taskFootprint(uid);
+    const brief = rowsOf(
+      `SELECT a.value FROM attachments a WHERE a.target_uid = ? AND a.role IS NOT NULL
+       UNION SELECT a.value FROM attachments a JOIN plan_items pg ON pg.uid = a.target_uid
+        WHERE a.role = 'material' AND pg.kind = 'object' AND pg.plan_uid = (SELECT plan_uid FROM plan_items WHERE uid = ?)`,
+      [uid, uid]
+    ).map((r) => r.value);
+    return {
+      id: (0, import_task_workstreams.taskWorkstreamId)(uid),
+      title: titleOf(uid),
+      brief,
+      reads: f.read.map((m) => {
+        const owner = (m.attachmentUid ? ownerOf(m.attachmentUid) : null) ?? uid;
+        const last = m.reads[m.reads.length - 1]?.teammate;
+        const by = last ? `${last.name}${last.verified ? "" : ", unverified"}` : null;
+        return { path: m.path, sha256: m.lastSha256, owner: (0, import_task_workstreams.taskWorkstreamId)(owner), ownerTitle: titleOf(owner), ...by ? { by } : {} };
+      }),
+      outputs: f.outputs.map((o) => o.path),
+      cited: f.cited.map((c) => ({ path: c.path, part: partWords(c.locator), sha256: c.sha256AtCite, signedOff: c.signedOff }))
+    };
+  });
+  const current = {};
+  const paths = new Set(tasks.flatMap((t) => [...t.reads.map((r) => r.path), ...t.cited.map((c) => c.path)]));
+  for (const p of paths) {
+    current[p] = rowsOf(
+      `SELECT a.sha256 FROM attachments a WHERE a.value = ? AND a.role IS NOT NULL AND a.target_uid IN (${inProject})
+        ORDER BY COALESCE(a.mtime, 0) DESC, a.created_at DESC LIMIT 1`,
+      [p, projectRoot, trimmed]
+    )[0]?.sha256 ?? null;
+  }
+  return { tasks, current };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  locatorKey,
+  materialInputsOf,
+  partWords,
+  readSoFar,
+  recordMaterialRead,
+  taskFootprint
+});

package/src/backend/services/material-place.js

@@ -0,0 +1,82 @@
+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);
+var material_place_exports = {};
+__export(material_place_exports, {
+  PLANS_PREFIX: () => PLANS_PREFIX,
+  isPlacePath: () => isPlacePath,
+  isStoredPlace: () => isStoredPlace,
+  locateStored: () => locateStored,
+  placeOf: () => placeOf
+});
+module.exports = __toCommonJS(material_place_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_plans_home = require("./plans-home");
+const PLANS_PREFIX = "plans://";
+function isPlacePath(value) {
+  return value.startsWith(PLANS_PREFIX);
+}
+function safeRel(rel) {
+  return rel.length > 0 && !import_node_path.default.isAbsolute(rel) && !/^[a-z]:/i.test(rel) && !rel.split(/[\\/]/).some((seg) => seg === ".." || seg === "");
+}
+function isStoredPlace(value) {
+  if (typeof value !== "string" || !value) return false;
+  const rel = isPlacePath(value) ? value.slice(PLANS_PREFIX.length) : value;
+  if (!isPlacePath(value) && /^[a-z][a-z0-9+.-]*:/i.test(value)) return false;
+  return safeRel(rel);
+}
+function locateStored(value, projectRoot) {
+  if (typeof value !== "string" || !value) return null;
+  if (isPlacePath(value)) {
+    const rel = value.slice(PLANS_PREFIX.length);
+    const home = (0, import_plans_home.plansHome)(projectRoot);
+    if (!home || !safeRel(rel)) return null;
+    return { root: home, rel };
+  }
+  if (import_node_path.default.isAbsolute(value) || /^[a-z][a-z0-9+.-]*:/i.test(value)) return null;
+  return { root: projectRoot, rel: value };
+}
+function placeOf(absPath, projectRoot) {
+  const inside = (root) => {
+    const rel = import_node_path.default.relative(root, absPath);
+    return rel && !rel.startsWith("..") && !import_node_path.default.isAbsolute(rel) ? rel.split(import_node_path.default.sep).join("/") : null;
+  };
+  const inProject = inside(projectRoot);
+  if (inProject) return inProject;
+  const home = (0, import_plans_home.plansHome)(projectRoot);
+  if (!home || home === projectRoot) return null;
+  const inFolder = inside(home);
+  return inFolder ? `${PLANS_PREFIX}${inFolder}` : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PLANS_PREFIX,
+  isPlacePath,
+  isStoredPlace,
+  locateStored,
+  placeOf
+});

package/src/backend/services/material-reader/docx-markdown.js

@@ -0,0 +1,198 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var docx_markdown_exports = {};
+__export(docx_markdown_exports, {
+  docxHtmlToMarkdown: () => docxHtmlToMarkdown
+});
+module.exports = __toCommonJS(docx_markdown_exports);
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " " };
+function decode(s) {
+  return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => {
+    if (e[0] === "#") {
+      const n = e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : Number(e.slice(1));
+      return Number.isFinite(n) && n > 0 && n <= 1114111 ? String.fromCodePoint(n) : m;
+    }
+    return ENTITIES[e.toLowerCase()] ?? m;
+  });
+}
+function docxHtmlToMarkdown(html) {
+  const out = [];
+  const lists = [];
+  const tables = [];
+  let line = "";
+  let prefix = "";
+  const links = [];
+  const write = (s) => {
+    const t = tables[tables.length - 1];
+    if (t && t.cell !== null) t.cell += s;
+    else line += s;
+  };
+  const flush = (blank) => {
+    const text = line.replace(/[ \t]+/g, " ").trim();
+    if (text) out.push(prefix + text);
+    if (blank && out.length && out[out.length - 1] !== "") out.push("");
+    line = "";
+    prefix = "";
+  };
+  for (const m of html.matchAll(/<(\/?)([a-z][a-z0-9]*)\b([^>]*?)\/?>|([^<]+)/gi)) {
+    if (m[4] !== void 0) {
+      write(decode(m[4]));
+      continue;
+    }
+    const closing = m[1] === "/";
+    const tag = m[2].toLowerCase();
+    const attrs = m[3] ?? "";
+    const inCell = tables.length > 0 && tables[tables.length - 1].cell !== null;
+    switch (tag) {
+      case "h1":
+      case "h2":
+      case "h3":
+      case "h4":
+      case "h5":
+      case "h6":
+        if (inCell) {
+          if (closing) write(" ");
+          break;
+        }
+        if (closing) flush(true);
+        else {
+          flush(false);
+          prefix = `${"#".repeat(Number(tag[1]))} `;
+        }
+        break;
+      case "p":
+        if (inCell) {
+          if (closing) write(" ");
+          break;
+        }
+        if (closing) flush(lists.length === 0);
+        else if (lists.length === 0) flush(false);
+        break;
+      case "ul":
+      case "ol":
+        if (inCell) break;
+        if (closing) {
+          flush(false);
+          lists.pop();
+          if (lists.length === 0 && out.length && out[out.length - 1] !== "") out.push("");
+        } else {
+          flush(false);
+          lists.push({ ordered: tag === "ol", n: 0 });
+        }
+        break;
+      case "li": {
+        if (inCell) {
+          write(closing ? "; " : "");
+          break;
+        }
+        if (closing) {
+          flush(false);
+          break;
+        }
+        flush(false);
+        const l = lists[lists.length - 1];
+        const depth = Math.max(0, lists.length - 1);
+        prefix = `${"  ".repeat(depth)}${l?.ordered ? `${++l.n}.` : "-"} `;
+        break;
+      }
+      case "table":
+        if (!closing) {
+          if (!inCell) flush(true);
+          tables.push({ rows: [], row: null, cell: null });
+        } else {
+          const t = tables.pop();
+          if (!t) break;
+          if (tables.length > 0) {
+            write(t.rows.map((r) => r.join(", ")).join("; "));
+          } else {
+            out.push(...gfmTable(t.rows), "");
+          }
+        }
+        break;
+      case "tr": {
+        const t = tables[tables.length - 1];
+        if (!t) break;
+        if (closing) {
+          if (t.row) t.rows.push(t.row);
+          t.row = null;
+        } else t.row = [];
+        break;
+      }
+      case "td":
+      case "th": {
+        const t = tables[tables.length - 1];
+        if (!t) break;
+        if (closing) {
+          (t.row ??= []).push((t.cell ?? "").replace(/\s+/g, " ").trim());
+          t.cell = null;
+        } else t.cell = "";
+        break;
+      }
+      case "strong":
+      case "b":
+        write("**");
+        break;
+      case "em":
+      case "i":
+        write("_");
+        break;
+      case "s":
+      case "del":
+        write("~~");
+        break;
+      case "br":
+        if (inCell) write(" ");
+        else {
+          flush(false);
+        }
+        break;
+      case "a": {
+        if (!closing) {
+          const href = attrs.match(/\bhref="([^"]*)"/)?.[1];
+          links.push(href ? decode(href) : null);
+          if (href) write("[");
+        } else {
+          const href = links.pop();
+          if (href) write(`](${href})`);
+        }
+        break;
+      }
+      case "img": {
+        const alt = attrs.match(/\balt="([^"]*)"/)?.[1];
+        write(alt ? `[image: ${decode(alt)}]` : "[image]");
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  flush(false);
+  while (out.length && out[out.length - 1] === "") out.pop();
+  return out.join("\n");
+}
+function gfmTable(rows) {
+  if (rows.length === 0) return [];
+  const width = Math.max(...rows.map((r) => r.length));
+  const cell = (s) => (s ?? "").replace(/\|/g, "\\|");
+  const line = (r) => `| ${Array.from({ length: width }, (_, i) => cell(r[i])).join(" | ")} |`;
+  return [line(rows[0]), `| ${Array.from({ length: width }, () => "---").join(" | ")} |`, ...rows.slice(1).map(line)];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  docxHtmlToMarkdown
+});