", re.I)
+_CELL_END = re.compile(r"", re.I) # cell boundary -> space, or
+# "MondayStrength" flattens to "MondayStrength" in drafted tables
+_TAG = re.compile(r"<[^>]+>")
+
+
+def _norm(text):
+ """Whitespace-insensitive comparison form (HTML collapses whitespace)."""
+ return re.sub(r"\s+", " ", (text or "").replace("\xa0", " ")).strip()
+
+
+def html_paragraphs(markup):
+ """Plain-text paragraphs of a block-level HTML fragment, in order."""
+ paras = []
+ for chunk in _BLOCK_BREAK.split(_CELL_END.sub(" ", markup or "")):
+ # inline tags (, ...) vanish without leaving a space -
+ # "Friday." must yield "Friday.", not "Friday ."; paragraph
+ # boundaries were already handled by the block split above
+ text = _norm(_html.unescape(_TAG.sub("", chunk)))
+ if text:
+ paras.append(text)
+ return paras
+
+
+def _paragraphs(doc):
+ """Top-level text paragraphs of the document (table cells not included)."""
+ out = []
+ enum = doc.getText().createEnumeration()
+ while enum.hasMoreElements():
+ node = enum.nextElement()
+ if node.supportsService("com.sun.star.text.Paragraph"):
+ out.append(node)
+ return out
+
+
+def _find_runs(paras, wanted):
+ """Start indexes where consecutive paragraphs equal `wanted` (normalized)."""
+ texts = [_norm(p.getString()) for p in paras]
+ n = len(wanted)
+ return [i for i in range(len(texts) - n + 1) if texts[i:i + n] == wanted]
+
+
+def apply_change(doc, change):
+ """Apply one approved change. Returns (applied: bool, reason: str)."""
+ old_paras = html_paragraphs(change.get("old_html"))
+ new_paras = html_paragraphs(change.get("new_html"))
+ if not old_paras:
+ return False, "pure insertion (no anchor text) - apply manually"
+ # fresh scan for every change: an earlier write-back moves paragraphs
+ paras = _paragraphs(doc)
+ hits = _find_runs(paras, old_paras)
+ if not hits:
+ return False, "original text not found (inside a table, or already changed)"
+ if len(hits) > 1:
+ return False, f"ambiguous ({len(hits)} identical matches)"
+ first = paras[hits[0]]
+ last = paras[hits[0] + len(old_paras) - 1]
+ cursor = doc.getText().createTextCursorByRange(first.getStart())
+ cursor.gotoRange(last.getEnd(), True)
+ # setString keeps the range's styles; "\n" becomes a paragraph break
+ cursor.setString("\n".join(new_paras))
+ return True, "applied"
+
+
+def apply_changes(doc, pending):
+ """Apply approved changes range by range. Returns per-change result dicts."""
+ return [{"change_id": change.get("change_id"), "applied": applied, "reason": reason}
+ for change in pending
+ for applied, reason in [apply_change(doc, change)]]
+
+
+PARAGRAPH_BREAK = 0 # com.sun.star.text.ControlCharacter.PARAGRAPH_BREAK
+
+
+def insert_paragraphs(doc, paras, at_range=None):
+ """Insert plain-text paragraphs at at_range (default: end of document).
+
+ Existing content is never modified: if the insertion point sits in a
+ non-empty paragraph, a paragraph break is opened first. Returns the number
+ of paragraphs inserted.
+ """
+ text = at_range.getText() if at_range is not None else doc.getText()
+ if at_range is not None:
+ cursor = text.createTextCursorByRange(at_range.getEnd())
+ else:
+ cursor = text.createTextCursor()
+ cursor.gotoEnd(False)
+ probe = text.createTextCursorByRange(cursor)
+ probe.gotoStartOfParagraph(False)
+ probe.gotoEndOfParagraph(True)
+ if probe.getString().strip():
+ text.insertControlCharacter(cursor, PARAGRAPH_BREAK, False)
+ for i, para in enumerate(paras):
+ if i:
+ text.insertControlCharacter(cursor, PARAGRAPH_BREAK, False)
+ text.insertString(cursor, para, False)
+ return len(paras)
+
+
+def summarize(results):
+ """One status line, honest about anything skipped."""
+ done = sum(1 for r in results if r["applied"])
+ msg = f"Applied {done} of {len(results)} change(s) in place."
+ skipped = [r["reason"] for r in results if not r["applied"]]
+ if skipped:
+ msg += (" Skipped (document NOT touched for these): "
+ + "; ".join(skipped)
+ + ". The approved SuperDocs copy still has them - export it if needed.")
+ return msg
diff --git a/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/draft_live_test.py b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/draft_live_test.py
new file mode 100644
index 0000000..7413a40
--- /dev/null
+++ b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/draft_live_test.py
@@ -0,0 +1,61 @@
+"""Drafting-path LIVE test (plain HTTP, no LibreOffice needed, costs <= 1 op).
+
+Sends a drafting-style instruction ("create X") the way the sidebar does and
+verifies the client surfaces the created content as edit["draft_html"] when the
+job completes with zero pending changes (the B6 behavior: creation bypasses the
+approval gate). If the model instead proposes in-place edits, we reject them
+(free) and report that this run did not exercise the draft path - both outcomes
+are honest.
+
+Needs SUPERDOCS_API_KEY or ~/.superdocs/agent_credentials.json.
+Run: python3 tests/draft_live_test.py
+"""
+import base64
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src" / "pythonpath"))
+import superdocs_client as sc
+import writeback
+
+BASE = "Migration Plan"
+# mirror the whole-doc flow (the wording that reliably triggers creation):
+# upload a near-empty doc, then the exact message request_doc_edit sends
+session = "sdext-drafttest-" + time.strftime("%Y%m%d-%H%M%S")
+sc._call("POST", "/v1/documents/upload-base64", {
+ "filename": "passage.html",
+ "file_base64": base64.b64encode(
+ f"{BASE}".encode()).decode(),
+ "session_id": session,
+})
+edit = sc._open_edit(
+ session,
+ "create a plan to hit gym"
+ "\n\nApply targeted edits to this document; change only what "
+ "the instruction requires; do not add commentary or metadata.",
+ lambda m: print(" ", m))
+print("state:", edit["state"], "| pending:", len(edit["pending"]),
+ "| response:", (edit.get("response") or "")[:120])
+
+if edit["state"] == "awaiting_approval":
+ sc.finalize(edit, False, progress=lambda m: print(" ", m))
+ print("NOTE: model proposed in-place edits for this phrasing; rejected (free).")
+ print("DRAFT LIVE TEST: SKIPPED (draft path not taken this run - not a failure)")
+ sys.exit(0)
+
+paras = writeback.html_paragraphs(edit.get("draft_html"))
+checks = [
+ ("job completed with no pending changes", not edit["pending"]),
+ ("draft_html surfaced and non-empty", bool(paras)),
+ ("draft differs from the uploaded passage",
+ " ".join(paras) != writeback._norm(BASE)),
+]
+ok = True
+for name, passed in checks:
+ print(("PASS " if passed else "FAIL ") + name)
+ ok = ok and passed
+if ok:
+ print("draft paragraphs:", len(paras), "| first:", paras[0][:80])
+print("DRAFT LIVE TEST:", "ALL PASS" if ok else "FAILURES")
+sys.exit(0 if ok else 1)
diff --git a/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/layout_test.py b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/layout_test.py
new file mode 100644
index 0000000..28dfe91
--- /dev/null
+++ b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/layout_test.py
@@ -0,0 +1,115 @@
+"""Panel layout test (OFFLINE - plain python3, no LibreOffice, no key, 0 operations).
+
+Drives panel_layout.solve at every panel height from far below the floor to far
+above the preferred layout and proves the invariants the sidebar depends on:
+
+ 1. the status line is fully inside the panel at every size >= the reported
+ minimum - the bug this module exists to fix (a short office window used to
+ push it off the bottom)
+ 2. Apply/Reject are always visible, and always above the status line
+ 3. nothing overlaps and nothing sticks out sideways
+ 4. the instruction box, Send, the checkbox and the status line never vanish
+ 5. an empty preview takes no space at all; a filled one is visible whenever
+ the panel is above its floor
+ 6. extra height is absorbed, not left as dead space at the bottom
+ 7. the whole thing scales with the host's pixels-per-unit (HiDPI)
+
+Run: python3 tests/layout_test.py
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src" / "pythonpath"))
+import panel_layout as pl
+
+ALWAYS = ("chkWholeDoc", "txtInstruction", "btnSend", "btnApprove", "btnReject", "lblStatus")
+checks = []
+
+
+def check(name, passed):
+ checks.append((name, passed))
+
+
+for unit in (1.5, 2.0, 3.0): # 100%, standard, HiDPI
+ for has_preview in (False, True):
+ tag = f"[unit={unit} preview={'yes' if has_preview else 'no'}]"
+ floor = pl.stack_height(pl.FLOOR, unit, has_preview)
+ preferred = pl.stack_height(pl.PREF, unit, has_preview)
+ check(f"{tag} floor is well below preferred", 0 < floor < preferred)
+
+ for width in (int(80 * unit), int(130 * unit), int(300 * unit)):
+ # from half the floor (deck would scroll) to twice the preferred
+ for height in range(floor // 2, preferred * 2, 7):
+ boxes = dict(pl.solve(width, height, unit, has_preview))
+ shown = {k: v for k, v in boxes.items() if v}
+ where = f"{tag} {width}x{height}"
+
+ if height >= floor:
+ status = boxes["lblStatus"]
+ check(f"{where}: status is placed", bool(status))
+ if status:
+ check(f"{where}: status fits inside the panel",
+ status[1] + status[3] <= height)
+ check(f"{where}: status keeps a readable line",
+ status[3] >= int(round(10 * unit)))
+ for cid in ALWAYS:
+ check(f"{where}: {cid} still visible", bool(boxes[cid]))
+ approve, reject = boxes["btnApprove"], boxes["btnReject"]
+ check(f"{where}: decision buttons above the status line",
+ approve[1] + approve[3] <= status[1])
+ check(f"{where}: buttons share the row",
+ approve[1] == reject[1] and approve[3] == reject[3])
+ check(f"{where}: buttons align with both margins",
+ approve[0] == round(pl.PAD * unit)
+ and reject[0] + reject[2] == width - round(pl.PAD * unit))
+ check(f"{where}: buttons do not overlap",
+ approve[0] + approve[2] <= reject[0])
+
+ # ordering + no overlap, in the declared top-to-bottom order
+ stacked = [b for b in shown.values()]
+ # btnApprove stands in for the row it shares with btnReject
+ rows = [b for cid, b in pl.solve(width, height, unit, has_preview)
+ if b and cid != "btnReject"]
+ check(f"{where}: rows stack without overlapping",
+ all(a[1] + a[3] <= b[1] for a, b in zip(rows, rows[1:])))
+ check(f"{where}: nothing overflows the panel width",
+ all(b[0] >= 0 and b[0] + b[2] <= width for b in stacked))
+ check(f"{where}: full-width rows share one width",
+ len({b[2] for cid, b in shown.items()
+ if cid not in ("btnApprove", "btnReject")}) == 1)
+ check(f"{where}: nothing starts above the top margin",
+ all(b[1] >= round(pl.PAD * unit) for b in stacked))
+
+ check(f"{where}: empty preview takes no room",
+ has_preview or boxes["lblPreview"] is None)
+ if has_preview and height >= preferred:
+ check(f"{where}: filled preview is shown", bool(boxes["lblPreview"]))
+
+ if height >= preferred:
+ bottom = max(b[1] + b[3] for b in stacked)
+ check(f"{where}: spare height is absorbed, not left dangling",
+ bottom >= height - round(pl.PAD * unit) - 1)
+
+# a tall panel gives the flexible boxes more than they ask for
+tall = dict(pl.solve(260, 900, 2.0, True))
+pref = dict(pl.solve(260, pl.stack_height(pl.PREF, 2.0, True), 2.0, True))
+for cid in ("lblPreview", "txtInstruction", "lblStatus"):
+ check(f"tall panel grows {cid}", tall[cid][3] > pref[cid][3])
+for cid in ("btnSend", "btnApprove", "chkWholeDoc"):
+ check(f"tall panel leaves {cid} at its natural height", tall[cid][3] == pref[cid][3])
+
+# a squeezed panel drops the decoration first, never the working controls
+squeezed = dict(pl.solve(260, pl.stack_height(pl.FLOOR, 2.0, True), 2.0, True))
+check("floor layout drops the hint text", squeezed["lblHint"] is None)
+check("floor layout keeps every working control",
+ all(squeezed[cid] for cid in ALWAYS))
+
+ok = True
+for name, passed in checks:
+ if not passed:
+ print("FAIL " + name)
+ ok = ok and passed
+print(f"{len(checks)} assertions over "
+ f"{len({n.split(':')[0] for n, _ in checks})} panel sizes")
+print("PANEL LAYOUT TEST:", "ALL PASS" if ok else "FAILURES")
+sys.exit(0 if ok else 1)
diff --git a/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/run_style_test.sh b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/run_style_test.sh
new file mode 100644
index 0000000..198a236
--- /dev/null
+++ b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/run_style_test.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+# Style-respect test harness (Linux).
+# Starts a throwaway headless LibreOffice on an ISOLATED profile (does not
+# touch your normal LibreOffice or its profile) and runs the UNO test on it.
+# Needs: libreoffice-writer, python3-uno, and SUPERDOCS_API_KEY (or
+# ~/.superdocs/agent_credentials.json). Costs 1 SuperDocs operation.
+set -u
+HERE="$(cd "$(dirname "$0")" && pwd)"
+PROFILE=/tmp/lotest-superdocs
+rm -rf "$PROFILE"
+soffice --headless --invisible --norestore \
+ "-env:UserInstallation=file://$PROFILE" \
+ --accept="socket,host=localhost,port=2002;urp;" &
+LOPID=$!
+PYTHONPATH=/usr/lib/libreoffice/program timeout 240 python3 "$HERE/style_respect_test.py"
+RC=$?
+kill "$LOPID" 2>/dev/null
+exit "$RC"
diff --git a/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/run_whole_doc_live_test.sh b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/run_whole_doc_live_test.sh
new file mode 100644
index 0000000..ec8808e
--- /dev/null
+++ b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/run_whole_doc_live_test.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+# Whole-document LIVE round-trip harness (Linux). Costs 1 SuperDocs operation.
+# Needs: libreoffice-writer, python3-uno, and SUPERDOCS_API_KEY (or
+# ~/.superdocs/agent_credentials.json). Isolated profile, port 2004.
+set -u
+HERE="$(cd "$(dirname "$0")" && pwd)"
+PROFILE=/tmp/lotest-superdocs-wholedoc-live
+rm -rf "$PROFILE"
+soffice --headless --invisible --norestore \
+ "-env:UserInstallation=file://$PROFILE" \
+ --accept="socket,host=localhost,port=2004;urp;" &
+LOPID=$!
+PYTHONPATH=/usr/lib/libreoffice/program timeout 600 python3 "$HERE/whole_doc_live_test.py"
+RC=$?
+kill "$LOPID" 2>/dev/null
+exit "$RC"
diff --git a/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/run_whole_doc_test.sh b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/run_whole_doc_test.sh
new file mode 100644
index 0000000..f34f148
--- /dev/null
+++ b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/run_whole_doc_test.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+# Whole-document write-back test harness (Linux). OFFLINE: no API key needed,
+# costs 0 operations. Starts a throwaway headless LibreOffice on an ISOLATED
+# profile (port 2003, so it can run alongside run_style_test.sh) and drives
+# writeback.apply_changes against a real Writer document.
+# Needs: libreoffice-writer, python3-uno.
+set -u
+HERE="$(cd "$(dirname "$0")" && pwd)"
+PROFILE=/tmp/lotest-superdocs-wholedoc
+rm -rf "$PROFILE"
+soffice --headless --invisible --norestore \
+ "-env:UserInstallation=file://$PROFILE" \
+ --accept="socket,host=localhost,port=2003;urp;" &
+LOPID=$!
+PYTHONPATH=/usr/lib/libreoffice/program timeout 240 python3 "$HERE/whole_doc_test.py"
+RC=$?
+kill "$LOPID" 2>/dev/null
+exit "$RC"
diff --git a/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/style_respect_test.py b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/style_respect_test.py
new file mode 100644
index 0000000..9b3614b
--- /dev/null
+++ b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/style_respect_test.py
@@ -0,0 +1,122 @@
+"""Styled-document respect test (headless Linux, costs 1 operation).
+
+Builds a Writer doc with Heading 1 + body + bullet list + table, edits ONE body
+paragraph through the same client + setString path the sidebar panel uses, then
+asserts every style survived and nothing else changed.
+
+Run via run_style_test.sh (starts the headless office this connects to).
+"""
+import sys
+import time
+from pathlib import Path
+
+import uno
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src" / "pythonpath"))
+import superdocs_client as sc
+
+
+def connect(retries=40):
+ local = uno.getComponentContext()
+ resolver = local.ServiceManager.createInstanceWithContext(
+ "com.sun.star.bridge.UnoUrlResolver", local)
+ for _ in range(retries):
+ try:
+ return resolver.resolve(
+ "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext")
+ except Exception:
+ time.sleep(2)
+ raise RuntimeError("could not connect to soffice on port 2002")
+
+
+ctx = connect()
+smgr = ctx.ServiceManager
+desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
+doc = desktop.loadComponentFromURL("private:factory/swriter", "_blank", 0, ())
+text = doc.getText()
+cursor = text.createTextCursor()
+
+SLOPPY = "we gonna move the db next week, dont worry bout downtime it should be fine probably."
+
+# Style names differ across LibreOffice generations ("List Bullet" family was
+# dropped around LO 26; bullets are "List 1".."List 5"). Discover, don't assume.
+pstyles = doc.getStyleFamilies().getByName("ParagraphStyles")
+_names = list(pstyles.getElementNames())
+_candidates = ([n for n in _names if "bullet" in n.lower()]
+ + [n for n in ("List 1", "List") if n in _names])
+if not _candidates:
+ print("no bullet/list style; available:", _names)
+ sys.exit(2)
+BULLET = _candidates[0]
+print("using bullet style:", BULLET)
+
+# heading
+cursor.ParaStyleName = "Heading 1"
+text.insertString(cursor, "Migration Plan", False)
+text.insertControlCharacter(cursor, 0, False) # PARAGRAPH_BREAK
+# body paragraph (the edit target)
+cursor.ParaStyleName = "Standard"
+text.insertString(cursor, SLOPPY, False)
+text.insertControlCharacter(cursor, 0, False)
+# bullet list
+cursor.ParaStyleName = BULLET
+text.insertString(cursor, "Backup verification", False)
+text.insertControlCharacter(cursor, 0, False)
+text.insertString(cursor, "Rollback rehearsal", False)
+text.insertControlCharacter(cursor, 0, False)
+# table
+table = doc.createInstance("com.sun.star.text.TextTable")
+table.initialize(2, 2)
+cursor.ParaStyleName = "Standard"
+text.insertTextContent(cursor, table, False)
+table.getCellByName("A1").setString("Owner")
+table.getCellByName("B1").setString("DBA team")
+table.getCellByName("A2").setString("Window")
+table.getCellByName("B2").setString("Sat 02:00")
+
+# locate the sloppy paragraph and select it as a range
+target = None
+enum = text.createEnumeration()
+while enum.hasMoreElements():
+ para = enum.nextElement()
+ if para.supportsService("com.sun.star.text.Paragraph") and para.getString() == SLOPPY:
+ target = para
+ break
+assert target is not None, "target paragraph not found"
+
+rng = text.createTextCursorByRange(target.getStart())
+rng.gotoEndOfParagraph(True)
+
+print("1) requesting edit via sidebar client ...")
+edit = sc.request_edit(rng.getString(), "Rewrite formally and precisely.",
+ progress=lambda m: print(" ", m))
+assert edit["state"] == "awaiting_approval", edit["state"]
+final = sc.finalize(edit, True, progress=lambda m: print(" ", m))
+print(" final:", final[:120])
+rng.setString(final) # exactly what the panel's write_back does
+
+# ---- assertions ----
+results = []
+paras = []
+enum = text.createEnumeration()
+while enum.hasMoreElements():
+ p = enum.nextElement()
+ if p.supportsService("com.sun.star.text.Paragraph"):
+ paras.append((p.ParaStyleName, p.getString()))
+
+results.append(("heading style intact", paras[0] == ("Heading 1", "Migration Plan")))
+results.append(("edited para kept Default style", paras[1][0] == "Standard"))
+results.append(("edited para text changed", paras[1][1] != SLOPPY and len(paras[1][1]) > 10))
+bullets = [p for p in paras if p[0] == BULLET]
+results.append(("both bullets intact",
+ [b[1] for b in bullets] == ["Backup verification", "Rollback rehearsal"]))
+cells = [table.getCellByName(n).getString() for n in ("A1", "B1", "A2", "B2")]
+results.append(("table cells untouched", cells == ["Owner", "DBA team", "Window", "Sat 02:00"]))
+
+ok = True
+for name, passed in results:
+ print(("PASS " if passed else "FAIL ") + name)
+ ok = ok and passed
+doc.close(False)
+print("STYLE TEST:", "ALL PASS" if ok else "FAILURES")
+sys.exit(0 if ok else 1)
diff --git a/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/whole_doc_live_test.py b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/whole_doc_live_test.py
new file mode 100644
index 0000000..15c2abe
--- /dev/null
+++ b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/whole_doc_live_test.py
@@ -0,0 +1,121 @@
+"""Whole-document LIVE round-trip test (headless Linux, costs 1 operation).
+
+The offline test (whole_doc_test.py) proves the write-back mechanics; this one
+proves the integration: a real Writer doc exported as .docx through the host
+filter, sent through request_doc_edit, approved, and written back range by
+range from the ACTUAL old_html/new_html SuperDocs returned.
+
+Needs SUPERDOCS_API_KEY or ~/.superdocs/agent_credentials.json.
+Run via run_whole_doc_live_test.sh.
+"""
+import os
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+import uno
+import unohelper
+from com.sun.star.beans import PropertyValue
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src" / "pythonpath"))
+import superdocs_client as sc
+import writeback
+
+
+def connect(retries=40):
+ local = uno.getComponentContext()
+ resolver = local.ServiceManager.createInstanceWithContext(
+ "com.sun.star.bridge.UnoUrlResolver", local)
+ for _ in range(retries):
+ try:
+ return resolver.resolve(
+ "uno:socket,host=localhost,port=2004;urp;StarOffice.ComponentContext")
+ except Exception:
+ time.sleep(2)
+ raise RuntimeError("could not connect to soffice on port 2004")
+
+
+ctx = connect()
+desktop = ctx.ServiceManager.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
+doc = desktop.loadComponentFromURL("private:factory/swriter", "_blank", 0, ())
+text = doc.getText()
+cursor = text.createTextCursor()
+
+TARGET = "The supplier will try to deliver stuff sometime soon, no promises."
+KEEP = "Payment terms are net thirty days from the invoice date."
+
+
+def para(style, content):
+ cursor.ParaStyleName = style
+ text.insertString(cursor, content, False)
+ text.insertControlCharacter(cursor, 0, False) # PARAGRAPH_BREAK
+
+
+para("Heading 1", "Service Agreement")
+para("Standard", TARGET)
+para("Standard", KEEP)
+table = doc.createInstance("com.sun.star.text.TextTable")
+table.initialize(1, 2)
+cursor.ParaStyleName = "Standard"
+text.insertTextContent(cursor, table, False)
+table.getCellByName("A1").setString("Owner")
+table.getCellByName("B1").setString("Procurement")
+
+# export exactly the way the panel does
+fd, path = tempfile.mkstemp(suffix=".docx")
+os.close(fd)
+prop = PropertyValue()
+prop.Name = "FilterName"
+prop.Value = "MS Word 2007 XML"
+doc.storeToURL(unohelper.systemPathToFileUrl(path), (prop,))
+with open(path, "rb") as f:
+ docx_bytes = f.read()
+os.remove(path)
+print(f"1) exported {len(docx_bytes)} bytes, requesting whole-doc edit ...")
+
+edit = sc.request_doc_edit(
+ docx_bytes,
+ "Rewrite the vague delivery sentence into a formal commitment to deliver "
+ "within 10 business days. Leave every other part of the document unchanged.",
+ progress=lambda m: print(" ", m))
+assert edit["state"] == "awaiting_approval", edit["state"]
+for c in edit["pending"]:
+ print(" pending old:", (c.get("old_html") or "")[:100])
+ print(" pending new:", (c.get("new_html") or "")[:100])
+
+print("2) approving ...")
+sc.finalize(edit, True, progress=lambda m: print(" ", m), want_text=False)
+
+print("3) writing back range by range ...")
+results = writeback.apply_changes(doc, edit["pending"])
+for r in results:
+ print(" ", r)
+
+paras = []
+enum = text.createEnumeration()
+while enum.hasMoreElements():
+ p = enum.nextElement()
+ if p.supportsService("com.sun.star.text.Paragraph"):
+ paras.append((p.ParaStyleName, p.getString()))
+texts = [t for _, t in paras]
+
+checks = [
+ ("at least one change applied", any(r["applied"] for r in results)),
+ ("vague sentence gone", TARGET not in texts),
+ ("replacement kept Standard style",
+ all(s == "Standard" for s, t in paras if TARGET[:20] not in t and t not in
+ ("Service Agreement",) and t.strip())),
+ ("untouched paragraph identical", KEEP in texts),
+ ("heading untouched", paras[0] == ("Heading 1", "Service Agreement")),
+ ("table untouched",
+ [table.getCellByName(n).getString() for n in ("A1", "B1")] == ["Owner", "Procurement"]),
+]
+
+ok = True
+for name, passed in checks:
+ print(("PASS " if passed else "FAIL ") + name)
+ ok = ok and passed
+doc.close(False)
+print("WHOLE-DOC LIVE TEST:", "ALL PASS" if ok else "FAILURES")
+sys.exit(0 if ok else 1)
diff --git a/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/whole_doc_test.py b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/whole_doc_test.py
new file mode 100644
index 0000000..c39ada7
--- /dev/null
+++ b/extensions/vanamkarthiknetha/superdocs-writer-sidebar/tests/whole_doc_test.py
@@ -0,0 +1,169 @@
+"""Whole-document write-back test (headless Linux, OFFLINE - no key, 0 operations).
+
+Exercises writeback.apply_changes with a synthetic pending-changes list against
+a real Writer document, proving the write-back invariants the sidebar relies on:
+
+ 1. a unique single-paragraph match is replaced in place, styles intact
+ 2. a multi-paragraph run is matched as ONE range and replaced
+ 3. an ambiguous match (duplicate text) is SKIPPED, both copies untouched
+ 4. text not in the document is SKIPPED
+ 5. table-cell content is out of scope -> SKIPPED, table untouched
+ 6. everything not matched stays exactly as it was
+
+Run via run_whole_doc_test.sh (starts the headless office this connects to).
+"""
+import sys
+import time
+from pathlib import Path
+
+import uno
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src" / "pythonpath"))
+import writeback
+
+
+def connect(retries=40):
+ local = uno.getComponentContext()
+ resolver = local.ServiceManager.createInstanceWithContext(
+ "com.sun.star.bridge.UnoUrlResolver", local)
+ for _ in range(retries):
+ try:
+ return resolver.resolve(
+ "uno:socket,host=localhost,port=2003;urp;StarOffice.ComponentContext")
+ except Exception:
+ time.sleep(2)
+ raise RuntimeError("could not connect to soffice on port 2003")
+
+
+ctx = connect()
+smgr = ctx.ServiceManager
+desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
+doc = desktop.loadComponentFromURL("private:factory/swriter", "_blank", 0, ())
+text = doc.getText()
+cursor = text.createTextCursor()
+
+BODY = "The vendor shall deliver the report by friday, probably."
+RUN_A = "First step of the rollout."
+RUN_B = "Second step of the rollout."
+DUP = "This sentence appears twice."
+
+
+def para(style, content):
+ cursor.ParaStyleName = style
+ text.insertString(cursor, content, False)
+ text.insertControlCharacter(cursor, 0, False) # PARAGRAPH_BREAK
+
+
+para("Heading 1", "Contract Summary")
+para("Standard", BODY)
+para("Standard", RUN_A)
+para("Standard", RUN_B)
+para("Standard", DUP)
+para("Standard", DUP)
+table = doc.createInstance("com.sun.star.text.TextTable")
+table.initialize(1, 2)
+cursor.ParaStyleName = "Standard"
+text.insertTextContent(cursor, table, False)
+table.getCellByName("A1").setString("Owner")
+table.getCellByName("B1").setString("Legal team")
+
+pending = [
+ # 1. unique single paragraph -> applied (entities + inline tags on purpose)
+ {"change_id": "c1",
+ "old_html": f"{BODY} ",
+ "new_html": "The vendor shall deliver the report by Friday 17:00. "},
+ # 2. two consecutive paragraphs -> ONE range, collapsed to one paragraph
+ {"change_id": "c2",
+ "old_html": f"{RUN_A} {RUN_B} ",
+ "new_html": "Both rollout steps, merged. "},
+ # 3. ambiguous -> skipped
+ {"change_id": "c3",
+ "old_html": f"{DUP} ",
+ "new_html": "should never land "},
+ # 4. not in document -> skipped
+ {"change_id": "c4",
+ "old_html": "text that exists nowhere in this file ",
+ "new_html": "should never land "},
+ # 5. table cell -> out of scope, skipped
+ {"change_id": "c5",
+ "old_html": "Owner ",
+ "new_html": "should never land "},
+]
+
+results = writeback.apply_changes(doc, pending)
+by_id = {r["change_id"]: r for r in results}
+
+paras = []
+enum = text.createEnumeration()
+while enum.hasMoreElements():
+ p = enum.nextElement()
+ if p.supportsService("com.sun.star.text.Paragraph"):
+ paras.append((p.ParaStyleName, p.getString()))
+texts = [p[1] for p in paras]
+
+checks = [
+ ("c1 applied", by_id["c1"]["applied"]),
+ ("c1 text landed (entities decoded, tags stripped)",
+ "The vendor shall deliver the report by Friday 17:00." in texts),
+ ("c1 kept Standard style",
+ any(s == "Standard" and t.startswith("The vendor shall deliver")
+ for s, t in paras)),
+ ("c2 applied", by_id["c2"]["applied"]),
+ ("c2 run collapsed to one paragraph",
+ texts.count("Both rollout steps, merged.") == 1
+ and RUN_A not in texts and RUN_B not in texts),
+ ("c3 skipped as ambiguous", not by_id["c3"]["applied"]
+ and "ambiguous" in by_id["c3"]["reason"]),
+ ("c3 both duplicates untouched", texts.count(DUP) == 2),
+ ("c4 skipped as not found", not by_id["c4"]["applied"]),
+ ("c5 skipped (table out of scope)", not by_id["c5"]["applied"]),
+ ("table untouched",
+ [table.getCellByName(n).getString() for n in ("A1", "B1")] == ["Owner", "Legal team"]),
+ ("heading untouched", paras[0] == ("Heading 1", "Contract Summary")),
+ ("nothing bogus landed", "should never land" not in texts),
+]
+
+# ---- draft insertion (v0.3.1): insert_paragraphs never touches existing text ----
+before_texts = list(texts)
+n_end = writeback.insert_paragraphs(doc, ["Draft alpha.", "Draft beta."]) # at end
+heading_para = None
+enum = text.createEnumeration()
+while enum.hasMoreElements():
+ p = enum.nextElement()
+ if p.supportsService("com.sun.star.text.Paragraph") and p.getString() == "Contract Summary":
+ heading_para = p
+ break
+n_mid = writeback.insert_paragraphs(doc, ["Inserted after heading."], heading_para)
+
+paras2 = []
+enum = text.createEnumeration()
+while enum.hasMoreElements():
+ p = enum.nextElement()
+ if p.supportsService("com.sun.star.text.Paragraph"):
+ paras2.append((p.ParaStyleName, p.getString()))
+texts2 = [t for _, t in paras2]
+nonempty2 = [t for t in texts2 if t.strip()]
+
+checks += [
+ ("insert at end returned 2", n_end == 2),
+ ("draft paragraphs landed at end", nonempty2[-2:] == ["Draft alpha.", "Draft beta."]),
+ ("insert at range returned 1", n_mid == 1),
+ ("mid insert landed right after heading",
+ texts2[texts2.index("Contract Summary") + 1] == "Inserted after heading."),
+ ("heading text/style survived insertion", paras2[0] == ("Heading 1", "Contract Summary")),
+ # non-empty only: inserting at the end legitimately consumes the trailing
+ # EMPTY paragraph (writing into an empty paragraph touches no content)
+ ("every pre-insert non-empty paragraph still present in order",
+ [t for t in texts2 if t.strip() and t in before_texts]
+ == [t for t in before_texts if t.strip()]),
+ ("table survived insertion",
+ [table.getCellByName(n).getString() for n in ("A1", "B1")] == ["Owner", "Legal team"]),
+]
+
+ok = True
+for name, passed in checks:
+ print(("PASS " if passed else "FAIL ") + name)
+ ok = ok and passed
+doc.close(False)
+print("WHOLE-DOC WRITE-BACK TEST:", "ALL PASS" if ok else "FAILURES")
+sys.exit(0 if ok else 1)
|