bun-docx 0.3.0 → 0.4.0

package/dist/index.js

@@ -17712,9 +17712,72 @@ var init_insert = __esm(() => {
   init_jsx_dev_runtime();
 });
 
-// src/cli/read/index.ts
-var exports_read = {};
-__export(exports_read, {
+// src/cli/outline/build.ts
+function buildOutline(doc, options = {}) {
+  const stylePrefix = options.stylePrefix ?? "Heading";
+  const root = {
+    id: "",
+    locator: "",
+    level: 0,
+    style: "",
+    text: "",
+    children: []
+  };
+  const stack = [root];
+  for (const paragraph of headingParagraphs(doc.blocks, stylePrefix)) {
+    const level = headingLevel(paragraph.style, stylePrefix);
+    if (level === null)
+      continue;
+    while ((stack[stack.length - 1]?.level ?? 0) >= level)
+      stack.pop();
+    const parent = stack[stack.length - 1] ?? root;
+    const entry = {
+      id: paragraph.id,
+      locator: paragraph.id,
+      level,
+      style: paragraph.style ?? "",
+      text: paragraphText(paragraph),
+      children: []
+    };
+    parent.children.push(entry);
+    stack.push(entry);
+  }
+  return root.children;
+}
+function headingLevel(style, stylePrefix) {
+  if (!style)
+    return null;
+  if (!style.startsWith(stylePrefix))
+    return null;
+  const remainder = style.slice(stylePrefix.length).trim();
+  if (remainder === "")
+    return 1;
+  const parsed = Number(remainder);
+  if (!Number.isInteger(parsed) || parsed < 1)
+    return null;
+  return parsed;
+}
+function* headingParagraphs(blocks, stylePrefix) {
+  for (const block of blocks) {
+    if (block.type !== "paragraph")
+      continue;
+    if (headingLevel(block.style, stylePrefix) === null)
+      continue;
+    yield block;
+  }
+}
+function paragraphText(paragraph) {
+  let out = "";
+  for (const run19 of paragraph.runs) {
+    if (run19.type === "text")
+      out += run19.text;
+  }
+  return out;
+}
+
+// src/cli/outline/index.ts
+var exports_outline = {};
+__export(exports_outline, {
   run: () => run19
 });
 import { parseArgs as parseArgs16 } from "util";
@@ -17725,12 +17788,13 @@ async function run19(args) {
       args,
       allowPositionals: true,
       options: {
-        text: { type: "boolean" },
+        "style-prefix": { type: "string" },
         help: { type: "boolean", short: "h" }
       }
     });
-  } catch (e) {
-    return fail("USAGE", e instanceof Error ? e.message : String(e), HELP19);
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP19);
   }
   if (parsed.values.help) {
     await writeStdout(HELP19);
@@ -17739,6 +17803,77 @@ async function run19(args) {
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP19);
+  const stylePrefix = parsed.values["style-prefix"] ?? "Heading";
+  if (stylePrefix.length === 0) {
+    return fail("USAGE", "--style-prefix cannot be empty");
+  }
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  const outline = buildOutline(view.doc, { stylePrefix });
+  await respond({
+    ok: true,
+    operation: "outline",
+    path,
+    stylePrefix,
+    outline
+  });
+  return EXIT.OK;
+}
+var HELP19 = `docx outline \u2014 list headings as a hierarchical tree
+
+Usage:
+  docx outline FILE [options]
+
+Options:
+  --style-prefix S  paragraph-style prefix that marks a heading (default: "Heading")
+  -h, --help        show this help
+
+Walks top-level paragraphs whose style starts with the prefix and parses the
+trailing number as the heading level (e.g. "Heading1" \u2192 1, "Heading 2" \u2192 2).
+Paragraphs nested inside table cells are skipped \u2014 outlines reflect the
+document's structural skeleton, not embedded labels. Lower levels nest under
+higher ones; missing intermediate levels nest directly (H1 \u2192 H3 is fine).
+
+Output is JSON: an array of entries, each shaped like
+  { id, locator, level, style, text, children }.
+
+Examples:
+  docx outline doc.docx
+  docx outline doc.docx --style-prefix "Section"
+  docx outline doc.docx | jq '.outline[].text'
+`;
+var init_outline = __esm(() => {
+  init_respond();
+});
+
+// src/cli/read/index.ts
+var exports_read = {};
+__export(exports_read, {
+  run: () => run20
+});
+import { parseArgs as parseArgs17 } from "util";
+async function run20(args) {
+  let parsed;
+  try {
+    parsed = parseArgs17({
+      args,
+      allowPositionals: true,
+      options: {
+        text: { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (e) {
+    return fail("USAGE", e instanceof Error ? e.message : String(e), HELP20);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP20);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP20);
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
@@ -17746,7 +17881,7 @@ async function run19(args) {
   await respond(view.doc);
   return EXIT.OK;
 }
-var HELP19 = `docx read \u2014 print AST as JSON
+var HELP20 = `docx read \u2014 print AST as JSON
 
 Usage:
   docx read FILE [options]
@@ -17829,14 +17964,14 @@ function rebuildContainer(container, baseOffset, span, replacement, runPropertie
     if (placed)
       return;
     placed = true;
-    const run20 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
+    const run21 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
       runProperties,
       text: replacement
     }, undefined, false, undefined, this);
     newChildren.push(tracked && isParagraph ? /* @__PURE__ */ jsxDEV(Ins, {
       meta: mintMeta(tracked),
-      children: run20
-    }, undefined, false, undefined, this) : run20);
+      children: run21
+    }, undefined, false, undefined, this) : run21);
   };
   for (const child of container.children) {
     if (child.tag === "w:r") {
@@ -17896,14 +18031,14 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
     if (placed)
       return;
     placed = true;
-    const run20 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
+    const run21 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
       runProperties,
       text: replacement
     }, undefined, false, undefined, this);
     newChildren.push(tracked ? /* @__PURE__ */ jsxDEV(Ins, {
       meta: mintMeta(tracked),
-      children: run20
-    }, undefined, false, undefined, this) : run20);
+      children: run21
+    }, undefined, false, undefined, this) : run21);
   };
   for (const child of paragraph.children) {
     if (child.tag === "w:r") {
@@ -18027,8 +18162,8 @@ function sumInnerRunLengths(wrapper) {
 function mintMeta(tracked) {
   return { ...tracked.meta, revisionId: tracked.allocator.next() };
 }
-function convertRunTextToDelText(run20) {
-  for (const child of run20.children) {
+function convertRunTextToDelText(run21) {
+  for (const child of run21.children) {
     if (child.tag === "w:t")
       child.tag = "w:delText";
   }
@@ -18057,13 +18192,13 @@ var init_replace_span = __esm(() => {
 // src/cli/replace/index.ts
 var exports_replace2 = {};
 __export(exports_replace2, {
-  run: () => run20
+  run: () => run21
 });
-import { parseArgs as parseArgs17 } from "util";
-async function run20(args) {
+import { parseArgs as parseArgs18 } from "util";
+async function run21(args) {
   let parsed;
   try {
-    parsed = parseArgs17({
+    parsed = parseArgs18({
       args,
       allowPositionals: true,
       options: {
@@ -18078,21 +18213,21 @@ async function run20(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP20);
+    return fail("USAGE", message, HELP21);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP20);
+    await writeStdout(HELP21);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   const pattern = parsed.positionals[1];
   const replacement = parsed.positionals[2];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP20);
+    return fail("USAGE", "Missing FILE argument", HELP21);
   if (pattern == null)
-    return fail("USAGE", "Missing PATTERN argument", HELP20);
+    return fail("USAGE", "Missing PATTERN argument", HELP21);
   if (replacement == null) {
-    return fail("USAGE", "Missing REPLACEMENT argument", HELP20);
+    return fail("USAGE", "Missing REPLACEMENT argument", HELP21);
   }
   const ignoreCase = Boolean(parsed.values["ignore-case"]);
   const useRegex = Boolean(parsed.values.regex);
@@ -18194,7 +18329,7 @@ async function run20(args) {
   });
   return EXIT.OK;
 }
-var HELP20 = `docx replace \u2014 substitute text spans (sed for docx)
+var HELP21 = `docx replace \u2014 substitute text spans (sed for docx)
 
 Usage:
   docx replace FILE PATTERN REPLACEMENT [options]
@@ -18237,13 +18372,13 @@ var init_replace2 = __esm(() => {
 // src/cli/track-changes/index.tsx
 var exports_track_changes = {};
 __export(exports_track_changes, {
-  run: () => run21
+  run: () => run22
 });
-import { parseArgs as parseArgs18 } from "util";
-async function run21(args) {
+import { parseArgs as parseArgs19 } from "util";
+async function run22(args) {
   let parsed;
   try {
-    parsed = parseArgs18({
+    parsed = parseArgs19({
       args,
       allowPositionals: true,
       options: {
@@ -18254,18 +18389,18 @@ async function run21(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP21);
+    return fail("USAGE", message, HELP22);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP21);
+    await writeStdout(HELP22);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP21);
+    return fail("USAGE", "Missing FILE argument", HELP22);
   const mode = parsed.positionals[1];
   if (mode !== "on" && mode !== "off") {
-    return fail("USAGE", `Expected "on" or "off", got: ${mode ?? "<nothing>"}`, HELP21);
+    return fail("USAGE", `Expected "on" or "off", got: ${mode ?? "<nothing>"}`, HELP22);
   }
   const view = await openOrFail(path);
   if (typeof view === "number")
@@ -18317,7 +18452,7 @@ async function run21(args) {
   });
   return EXIT.OK;
 }
-var HELP21 = `docx track-changes \u2014 toggle the document's tracked-changes mode
+var HELP22 = `docx track-changes \u2014 toggle the document's tracked-changes mode
 
 Usage:
   docx track-changes FILE on|off [options]
@@ -18344,10 +18479,297 @@ var init_track_changes2 = __esm(() => {
   init_respond();
   init_jsx_dev_runtime();
 });
+
+// src/cli/wc/count.ts
+function countWords(text) {
+  const matches = text.match(/\S+/g);
+  return matches?.length ?? 0;
+}
+function paragraphText2(paragraph) {
+  let out = "";
+  for (const run23 of paragraph.runs) {
+    if (run23.type === "text")
+      out += run23.text;
+  }
+  return out;
+}
+function countWordsInBlocks(blocks) {
+  let total = 0;
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      total += countWords(paragraphText2(block));
+    } else if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          total += countWordsInBlocks(cell.blocks);
+        }
+      }
+    }
+  }
+  return total;
+}
+function findBlockById(blocks, blockId) {
+  for (const block of blocks) {
+    if (block.id === blockId)
+      return block;
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          const inner = findBlockById(cell.blocks, blockId);
+          if (inner)
+            return inner;
+        }
+      }
+    }
+  }
+  return null;
+}
+function countWordsInParagraphSpan(paragraph, start, end) {
+  const text = paragraphText2(paragraph);
+  const clampedEnd = Math.min(Math.max(end, 0), text.length);
+  const clampedStart = Math.min(Math.max(start, 0), clampedEnd);
+  return countWords(text.slice(clampedStart, clampedEnd));
+}
+function countWordsInRange(paragraphsInOrder, startBlockId, startOffset, endBlockId, endOffset) {
+  const startIndex = paragraphsInOrder.findIndex((p) => p.id === startBlockId);
+  const endIndex = paragraphsInOrder.findIndex((p) => p.id === endBlockId);
+  if (startIndex === -1 || endIndex === -1)
+    return 0;
+  if (endIndex < startIndex)
+    return 0;
+  if (startIndex === endIndex) {
+    const paragraph = paragraphsInOrder[startIndex];
+    if (!paragraph)
+      return 0;
+    return countWordsInParagraphSpan(paragraph, startOffset, endOffset);
+  }
+  let total = 0;
+  const first = paragraphsInOrder[startIndex];
+  if (first) {
+    total += countWordsInParagraphSpan(first, startOffset, paragraphText2(first).length);
+  }
+  for (let index = startIndex + 1;index < endIndex; index++) {
+    const middle = paragraphsInOrder[index];
+    if (middle)
+      total += countWords(paragraphText2(middle));
+  }
+  const last = paragraphsInOrder[endIndex];
+  if (last)
+    total += countWordsInParagraphSpan(last, 0, endOffset);
+  return total;
+}
+function flattenParagraphs(blocks) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      out.push(block);
+      continue;
+    }
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          out.push(...flattenParagraphs(cell.blocks));
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// src/cli/wc/index.ts
+var exports_wc = {};
+__export(exports_wc, {
+  run: () => run23
+});
+import { parseArgs as parseArgs20 } from "util";
+async function run23(args) {
+  let parsed;
+  try {
+    parsed = parseArgs20({
+      args,
+      allowPositionals: true,
+      options: {
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP23);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP23);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  const locatorInput = parsed.positionals[1];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP23);
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  if (!locatorInput) {
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      scope: "document",
+      words: countWordsInBlocks(view.doc.blocks)
+    });
+    return EXIT.OK;
+  }
+  let locator;
+  try {
+    locator = parseLocator(locatorInput);
+  } catch (error) {
+    if (error instanceof LocatorParseError) {
+      return fail("INVALID_LOCATOR", error.message);
+    }
+    throw error;
+  }
+  if (locator.kind === "comment" || locator.kind === "image") {
+    return fail("USAGE", `Locator ${locatorInput} addresses a ${locator.kind}, not text`, "wc accepts paragraph, span, range, table, and cell locators.");
+  }
+  const blocks = view.doc.blocks;
+  if (locator.kind === "block") {
+    const block = findBlockById(blocks, locator.blockId);
+    if (!block) {
+      return fail("BLOCK_NOT_FOUND", `Block not found: ${locator.blockId}`);
+    }
+    const words = block.type === "paragraph" ? countWords(paragraphText2(block)) : block.type === "table" ? countWordsInBlocks([block]) : 0;
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      locator: locatorInput,
+      scope: block.type,
+      words
+    });
+    return EXIT.OK;
+  }
+  if (locator.kind === "blockSpan") {
+    const block = findBlockById(blocks, locator.blockId);
+    if (!block || block.type !== "paragraph") {
+      return fail("BLOCK_NOT_FOUND", `Paragraph not found: ${locator.blockId}`);
+    }
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      locator: locatorInput,
+      scope: "paragraphSpan",
+      words: countWordsInParagraphSpan(block, locator.start, locator.end)
+    });
+    return EXIT.OK;
+  }
+  if (locator.kind === "range") {
+    const paragraphs = flattenParagraphs(blocks);
+    const startExists = paragraphs.some((p) => p.id === locator.start.blockId);
+    const endExists = paragraphs.some((p) => p.id === locator.end.blockId);
+    if (!startExists) {
+      return fail("BLOCK_NOT_FOUND", `Paragraph not found: ${locator.start.blockId}`);
+    }
+    if (!endExists) {
+      return fail("BLOCK_NOT_FOUND", `Paragraph not found: ${locator.end.blockId}`);
+    }
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      locator: locatorInput,
+      scope: "range",
+      words: countWordsInRange(paragraphs, locator.start.blockId, locator.start.offset, locator.end.blockId, locator.end.offset)
+    });
+    return EXIT.OK;
+  }
+  if (locator.kind === "cell") {
+    const cellPath = `${locator.tableId}:r${locator.row}c${locator.col}`;
+    if (!locator.inner) {
+      const cellBlocks = findCellBlocks(blocks, locator);
+      if (!cellBlocks) {
+        return fail("BLOCK_NOT_FOUND", `Cell not found: ${cellPath}`);
+      }
+      await respond({
+        ok: true,
+        operation: "wc",
+        path,
+        locator: locatorInput,
+        scope: "cell",
+        words: countWordsInBlocks(cellBlocks)
+      });
+      return EXIT.OK;
+    }
+    const innerBlockId = locator.inner.kind === "block" ? locator.inner.blockId : locator.inner.kind === "blockSpan" ? locator.inner.blockId : null;
+    if (!innerBlockId) {
+      return fail("USAGE", `Unsupported inner locator for cell: ${locatorInput}`, "Inside a cell, wc accepts pK or pK:S-E only.");
+    }
+    const composedId = `${cellPath}:${innerBlockId}`;
+    const block = findBlockById(blocks, composedId);
+    if (!block || block.type !== "paragraph") {
+      return fail("BLOCK_NOT_FOUND", `Paragraph not found: ${composedId}`);
+    }
+    const words = locator.inner.kind === "blockSpan" ? countWordsInParagraphSpan(block, locator.inner.start, locator.inner.end) : countWords(paragraphText2(block));
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      locator: locatorInput,
+      scope: locator.inner.kind === "blockSpan" ? "paragraphSpan" : "paragraph",
+      words
+    });
+    return EXIT.OK;
+  }
+  return fail("USAGE", `Unsupported locator: ${locatorInput}`);
+}
+function findCellBlocks(blocks, locator) {
+  const block = findBlockById(blocks, locator.tableId);
+  if (!block || block.type !== "table")
+    return null;
+  const row = block.rows[locator.row];
+  if (!row)
+    return null;
+  const cell = row.cells[locator.col];
+  if (!cell)
+    return null;
+  return cell.blocks;
+}
+var HELP23 = `docx wc \u2014 count words in a document or a locator-addressed slice
+
+Usage:
+  docx wc FILE [LOCATOR] [options]
+
+Locators (optional; default: whole document):
+  pN              whole paragraph N
+  pN:S-E          chars S..E within paragraph N
+  pN:S-pM:E       cross-paragraph range
+  tN              whole table
+  tN:rRcC         whole cell
+  tN:rRcC:pK      paragraph K inside that cell
+  tN:rRcC:pK:S-E  span within a cell paragraph
+
+Options:
+  -h, --help        show this help
+
+Counting is whitespace-segmented (\\S+) over the joined paragraph text. Hidden
+content like images/breaks/tabs contributes no words. Tracked-change deletions
+are counted alongside insertions because their characters are still part of the
+on-disk text; accept or reject changes first if you need a delta on the
+"accepted" view.
+
+Examples:
+  docx wc doc.docx
+  docx wc doc.docx p3
+  docx wc doc.docx p3:0-120
+  docx wc doc.docx p5:10-p9:42
+  docx wc doc.docx t0:r1c0
+`;
+var init_wc = __esm(() => {
+  init_core();
+  init_respond();
+});
 // package.json
 var package_default = {
   name: "bun-docx",
-  version: "0.3.0",
+  version: "0.4.0",
   description: "CLI for AI agents (Claude, Codex) to read, edit, and comment on .docx files with full format fidelity.",
   keywords: [
     "docx",
@@ -18422,6 +18844,8 @@ Commands:
   delete    FILE  Remove a block or run range
   find      FILE QUERY  Find text spans, return locators
   replace   FILE PATTERN REPL  Substitute text spans (sed for docx)
+  wc        FILE [LOCATOR]  Count words in the doc or a slice
+  outline   FILE  List headings as a hierarchical tree
   comments  \u2026     Add, reply, resolve, delete, list comments
   images    \u2026     Extract, replace, list images
   track-changes FILE on|off  Toggle tracked-changes mode
@@ -18453,9 +18877,11 @@ var COMMANDS = {
   images: () => Promise.resolve().then(() => (init_images(), exports_images)),
   info: () => Promise.resolve().then(() => (init_info(), exports_info)),
   insert: () => Promise.resolve().then(() => (init_insert(), exports_insert)),
+  outline: () => Promise.resolve().then(() => (init_outline(), exports_outline)),
   read: () => Promise.resolve().then(() => (init_read2(), exports_read)),
   replace: () => Promise.resolve().then(() => (init_replace2(), exports_replace2)),
-  "track-changes": () => Promise.resolve().then(() => (init_track_changes2(), exports_track_changes))
+  "track-changes": () => Promise.resolve().then(() => (init_track_changes2(), exports_track_changes)),
+  wc: () => Promise.resolve().then(() => (init_wc(), exports_wc))
 };
 async function main(argv) {
   const args = argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bun-docx",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"description": "CLI for AI agents (Claude, Codex) to read, edit, and comment on .docx files with full format fidelity.",
 	"keywords": [
 		"docx",