docslicer 0.2.2__tar.gz → 0.2.4__tar.gz

{docslicer-0.2.2/src/docslicer.egg-info → docslicer-0.2.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: docslicer
-Version: 0.2.2
-Summary: Deterministic hierarchical document parser and chunker
+Version: 0.2.4
+Summary: Answer questions from documents too large to fit in context, reading only the sections you need
 Author-email: "Market Framer Inc." <jelle@docslicer.ai>
 License-Expression: AGPL-3.0-only
 Project-URL: Homepage, https://docslicer.ai
@@ -665,7 +665,8 @@ document and the next `parse` re-parses it automatically.
 
 | Variable | Effect |
 | --- | --- |
-| `DOCSLICER_MCP_ROOT` | Restrict file sources **and** written output to this directory tree |
+| `DOCSLICER_MCP_ROOT` | Restrict file sources **and** written output to this directory tree. Several may be given, separated by `:` (`;` on Windows) |
+| `DOCSLICER_MCP_ALLOW_CLAUDE_DIR` | Set to `0` to drop the Claude desktop app's own directory from the allowed roots (default `1`) |
 | `DOCSLICER_MCP_ALLOW_URLS` | Set to `0` to reject `http(s)` sources |
 | `DOCSLICER_MCP_CACHE` | Where parsed results are persisted (default `~/.cache/docslicer-mcp`) |
 | `DOCSLICER_MCP_CACHE_MAX_MB` | Cache size ceiling, oldest pruned first (default `2048`; `0` disables) |
@@ -674,6 +675,21 @@ Set `DOCSLICER_MCP_ROOT` when exposing the server to anything but yourself —
 without it, any readable path on the machine is parseable, and `to_markdown`
 can write anywhere the server process can.
 
+**Documents dropped into a chat.** Attaching a file to a Claude conversation
+does not hand the server the path you know it by: the app first copies it into
+a per-session workspace under its own data directory (`~/Library/Application
+Support/Claude` on macOS, `%APPDATA%\Claude` on Windows), which is nowhere near
+the folder you would have picked as your root. That directory is therefore
+allowed alongside `DOCSLICER_MCP_ROOT`, so both routes work — the folder you
+chose, and whatever you drop into the chat. It is only ever *added* to a root
+you set; leaving `DOCSLICER_MCP_ROOT` unset still means no sandbox at all, not
+a sandbox of that one directory. Set `DOCSLICER_MCP_ALLOW_CLAUDE_DIR=0` to opt
+out and accept only your own roots.
+
+`to_markdown` writes beside the source document, except for a document dropped
+into a chat: that copy lives in a session folder you cannot navigate to, so the
+markdown goes to your first `DOCSLICER_MCP_ROOT` instead.
+
 ---
 
 ## Command line

{docslicer-0.2.2 → docslicer-0.2.4}/README.md

@@ -605,7 +605,8 @@ document and the next `parse` re-parses it automatically.
 
 | Variable | Effect |
 | --- | --- |
-| `DOCSLICER_MCP_ROOT` | Restrict file sources **and** written output to this directory tree |
+| `DOCSLICER_MCP_ROOT` | Restrict file sources **and** written output to this directory tree. Several may be given, separated by `:` (`;` on Windows) |
+| `DOCSLICER_MCP_ALLOW_CLAUDE_DIR` | Set to `0` to drop the Claude desktop app's own directory from the allowed roots (default `1`) |
 | `DOCSLICER_MCP_ALLOW_URLS` | Set to `0` to reject `http(s)` sources |
 | `DOCSLICER_MCP_CACHE` | Where parsed results are persisted (default `~/.cache/docslicer-mcp`) |
 | `DOCSLICER_MCP_CACHE_MAX_MB` | Cache size ceiling, oldest pruned first (default `2048`; `0` disables) |
@@ -614,6 +615,21 @@ Set `DOCSLICER_MCP_ROOT` when exposing the server to anything but yourself —
 without it, any readable path on the machine is parseable, and `to_markdown`
 can write anywhere the server process can.
 
+**Documents dropped into a chat.** Attaching a file to a Claude conversation
+does not hand the server the path you know it by: the app first copies it into
+a per-session workspace under its own data directory (`~/Library/Application
+Support/Claude` on macOS, `%APPDATA%\Claude` on Windows), which is nowhere near
+the folder you would have picked as your root. That directory is therefore
+allowed alongside `DOCSLICER_MCP_ROOT`, so both routes work — the folder you
+chose, and whatever you drop into the chat. It is only ever *added* to a root
+you set; leaving `DOCSLICER_MCP_ROOT` unset still means no sandbox at all, not
+a sandbox of that one directory. Set `DOCSLICER_MCP_ALLOW_CLAUDE_DIR=0` to opt
+out and accept only your own roots.
+
+`to_markdown` writes beside the source document, except for a document dropped
+into a chat: that copy lives in a session folder you cannot navigate to, so the
+markdown goes to your first `DOCSLICER_MCP_ROOT` instead.
+
 ---
 
 ## Command line

{docslicer-0.2.2 → docslicer-0.2.4}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "docslicer"
-version = "0.2.2"
-description = "Deterministic hierarchical document parser and chunker"
+version = "0.2.4"
+description = "Answer questions from documents too large to fit in context, reading only the sections you need"
 readme = "README.md"
 license = "AGPL-3.0-only"
 license-files = ["LICENSE"]

{docslicer-0.2.2 → docslicer-0.2.4}/src/docslicer/__init__.py

@@ -20,7 +20,7 @@ try:
     from importlib.metadata import version as _pkg_version
     __version__ = _pkg_version("docslicer")
 except Exception:
-    __version__ = "0.2.2"
+    __version__ = "0.2.4"
 
 from ._config import ParseConfig
 from ._result import ParseResult, Chunk, Block, Table, TableCell, Chart, ChartPoint, BBox, HierarchyNode, HierarchyTree

{docslicer-0.2.2 → docslicer-0.2.4}/src/docslicer/_result.py

@@ -1110,7 +1110,8 @@ class ParseResult:
             if self.charts:
                 _to_parquet(self.charts_df(), path / "charts.parquet")
             (path / "metadata.json").write_text(
-                json.dumps(self.metadata.to_dict(), indent=2, ensure_ascii=False)
+                json.dumps(self.metadata.to_dict(), indent=2, ensure_ascii=False),
+                encoding="utf-8",
             )
             return
 
@@ -1129,20 +1130,29 @@ class ParseResult:
         if stem == "metadata":
             if suffix != ".json":
                 raise ValueError("metadata can only be saved as .json")
-            path.write_text(json.dumps(self.metadata.to_dict(), indent=2, ensure_ascii=False))
+            path.write_text(
+                json.dumps(self.metadata.to_dict(), indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
             return
 
         # Unknown stem (e.g. "result") → full document export
         if stem not in level_map:
             if suffix != ".json":
                 raise ValueError(f"Unknown stem {stem!r}: use chunks/blocks/tables/charts/metadata, or a .json path for a full export")
-            path.write_text(json.dumps(self.to_dict(), indent=2, ensure_ascii=False))
+            path.write_text(
+                json.dumps(self.to_dict(), indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
             return
 
         rows_fn = level_map[stem]
 
         if suffix == ".json":
-            path.write_text(json.dumps(rows_fn(), indent=2, ensure_ascii=False))
+            path.write_text(
+                json.dumps(rows_fn(), indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
         elif suffix == ".jsonl":
             with path.open("w", encoding="utf-8") as f:
                 for row in rows_fn():

{docslicer-0.2.2 → docslicer-0.2.4}/src/docslicer/_utils/df_aggregation/registry_aggregator.py

@@ -145,6 +145,7 @@ COLUMN_REGISTRY: Dict[str, Agg] = {
 
     # --- layout / reading order ----------------------------------------------
     "layout_id": Agg.FIRST,
+    "layout_cell_group": Agg.DROP,  # line-level only: groups the <td>s of a dissolved layout table
     "layout_type": Agg.FIRST,
     "layout_score": Agg.DROP, 
     "block_type": Agg.FIRST,

{docslicer-0.2.2 → docslicer-0.2.4}/src/docslicer/_utils/df_export/reorder_columns.py

@@ -101,6 +101,7 @@ MASTER_COLUMN_ORDER: List[str] = [
     "cell_id",
     "line_id",
     "layout_id",
+    "layout_cell_group",
     "cell_count",
     "paragraph_id",
     "gutter_id",

{docslicer-0.2.2 → docslicer-0.2.4}/src/docslicer/html/step_04_line_builder.py

@@ -20,17 +20,32 @@ from docslicer._utils.df_aggregation.text_merge import (
 # Build Line Text
 # =================================
 
-def _build_line_text(df: pd.DataFrame) -> pd.Series:
+def _build_line_text(df: pd.DataFrame, stacked: np.ndarray | None = None) -> pd.Series:
     """
     Build the text for each line: boxes sorted by x_left, non-table lines joined
     with spaces, table lines joined with pipes so downstream shared stages see a
     row-shaped representation. Inline markup (script/strikethrough) is already
     baked into box text by the box cleaner.
 
+    Args:
+        df: box-level frame carrying line_id.
+        stacked: optional boolean mask of boxes that stack vertically inside
+            their line (the layout-table cells split by
+            :func:`_split_layout_table_cell_lines`). Those boxes order by y first,
+            because a centred paragraph's x_left depends on its rendered width
+            and would otherwise come out widest-first. None (the normal case)
+            keeps the plain x_left sort.
+
     Returns:
         Series of joined text indexed by line_id.
     """
-    ordered = df.sort_values(["line_id", "x_left"], kind="stable")
+    if stacked is None:
+        ordered = df.sort_values(["line_id", "x_left"], kind="stable")
+    else:
+        # 0.0 everywhere else, so unstacked lines sort on x_left exactly as before.
+        df = df.assign(_stack_y=np.where(stacked, df["y_top"].to_numpy(dtype=float), 0.0))
+        ordered = df.sort_values(["line_id", "_stack_y", "x_left"], kind="stable")
+        ordered = ordered.drop(columns="_stack_y")
     texts = ordered["text"].astype("string").fillna("")
     # <pre> code-line boxes keep their leading whitespace — indentation is
     # semantically meaningful in code. Everything else is stripped as before.
@@ -60,6 +75,100 @@ def _build_line_text(df: pd.DataFrame) -> pd.Series:
     return line_text
 
 
+# =================================
+# Layout-table cells
+# =================================
+
+def _split_layout_table_cell_lines(df: pd.DataFrame) -> tuple[pd.DataFrame, np.ndarray | None]:
+    """
+    Give every ``<td>`` of a single-row *layout* table its own line_id.
+
+    A single-row table whose cells stack several paragraphs on top of each other
+    is a layout device, not data — the multi-column signature block where each
+    cell holds one law firm. ``assign_line_id`` merges a whole ``<tr>`` into one
+    line, which is right for a data row but here glues four firms into one line
+    and makes it impossible to tell which people belong to which firm. Splitting
+    per cell yields one line per column, in document (left-to-right) order.
+
+    ``_remove_single_row_tables`` dissolves these tables a few steps later, so no
+    downstream table stage ever sees the split rows.
+
+    The detection is a linear neighbour scan over the table boxes only: cells are
+    contiguous within a line, so a line has a multi-box cell iff two adjacent
+    boxes share (line_id, table_cell_index), and spans several cells iff two
+    adjacent boxes share line_id but not table_cell_index. Both must hold before
+    anything heavier than that scan runs, which on ordinary documents is never.
+
+    Returns:
+        (df, stacked_mask) — df with the split line_ids applied, and a boolean
+        mask of the boxes that were split (None when nothing qualified, i.e. the
+        frame is untouched).
+    """
+    needed = ("line_id", "table_id", "table_row_id", "table_cell_index")
+    if any(c not in df.columns for c in needed):
+        return df, None
+
+    is_table = df["table_id"].notna().to_numpy()
+    if not is_table.any():
+        return df, None
+
+    pos = np.flatnonzero(is_table)
+    line = df["line_id"].to_numpy()[pos]
+    cell = pd.to_numeric(df["table_cell_index"], errors="coerce").to_numpy(dtype=float)[pos]
+
+    same_line = line[1:] == line[:-1]
+    same_cell = cell[1:] == cell[:-1]
+    multi_box_cell = same_line & same_cell     # a cell holding >1 box
+    multi_cell_line = same_line & ~same_cell   # a line spanning >1 cell
+    if not (multi_box_cell.any() and multi_cell_line.any()):
+        return df, None
+
+    # Lines that are both — the only candidates worth a closer look.
+    candidates = np.intersect1d(line[1:][multi_box_cell], line[1:][multi_cell_line])
+    if candidates.size == 0:
+        return df, None
+
+    # Keep only candidates whose table is single-row: a wrapped cell in a real
+    # multi-row table looks identical to the scan above but must stay one line
+    # per row (step_05 relies on that).
+    line_all = df["line_id"].to_numpy()
+    on_candidate_line = is_table & np.isin(line_all, candidates)
+    cand_tables = df.loc[on_candidate_line, "table_id"].unique()
+    in_cand_tables = df["table_id"].isin(cand_tables)
+    rows_per_table = df.loc[in_cand_tables].groupby("table_id")["table_row_id"].nunique()
+    single_row = set(rows_per_table[rows_per_table == 1].index)
+    if not single_row:
+        return df, None
+
+    stacked = on_candidate_line & df["table_id"].isin(single_row).to_numpy()
+    if not stacked.any():
+        return df, None
+
+    # Renumber: a new line starts wherever line_id changes, plus at every cell
+    # boundary inside a split line. Boxes are in document order, so the cumsum
+    # keeps line_ids ascending exactly as assign_line_id left them.
+    cell_all = pd.to_numeric(df["table_cell_index"], errors="coerce").to_numpy(dtype=float)
+    starts = np.empty(len(df), dtype=bool)
+    starts[0] = True
+    starts[1:] = line_all[1:] != line_all[:-1]
+    cell_break = np.zeros(len(df), dtype=bool)
+    cell_break[1:] = stacked[1:] & stacked[:-1] & (cell_all[1:] != cell_all[:-1])
+
+    out = df.copy()
+    out["line_id"] = np.cumsum(starts | cell_break)
+
+    # top_bucket is derived from line_id by the merger; refresh it for the boxes
+    # whose line changed (it is dropped at aggregation, but the box-level frame
+    # is exported for debugging).
+    if "top_bucket" in out.columns:
+        split = out.loc[stacked]
+        out.loc[stacked, "top_bucket"] = (
+            split["line_id"].map(split.groupby("line_id")["y_top"].min().round().astype("Int64"))
+        )
+
+    return out, stacked
+
+
 # =================================
 # Table vs Text
 # =================================
@@ -268,6 +377,7 @@ def _add_layout_id(df: pd.DataFrame) -> pd.DataFrame:
        group key (new id when entering/leaving/switching groups). A line's
        group key is, in order of precedence:
        - its table_id
+       - its layout_cell_group (sibling <td>s of a dissolved layout table)
        - its deepest ul/ol or h1-h6 struct ancestor (see
          :func:`_struct_layout_groups`), so list items and multi-line
          headings stay together
@@ -300,6 +410,9 @@ def _add_layout_id(df: pd.DataFrame) -> pd.DataFrame:
 
     # Rule 3: group key — table_id wins over the struct list/heading group
     group_key = _struct_layout_groups(df)
+    if "layout_cell_group" in df.columns:
+        cell_group = df["layout_cell_group"].astype("string")
+        group_key = group_key.mask(cell_group.notna(), "cells_" + cell_group)
     if "table_id" in df.columns:
         has_table = df["table_id"].notna()
         group_key = group_key.mask(has_table, "table_" + df["table_id"].astype(str))
@@ -340,7 +453,8 @@ def merge_boxes_to_lines(
 ) -> pd.DataFrame:
     """
     Merge boxes into lines:
-    1. Assign line_id using line_merger
+    1. Assign line_id using line_merger, then split the cells of single-row
+       layout tables into their own lines
     2. Merge text within each line (sorted by x_left) via text_merge
     3. Aggregate the remaining columns via the registry aggregator
     4. Optionally remove single-row tables and reindex
@@ -391,12 +505,16 @@ def merge_boxes_to_lines(
         boxes_df["y_bottom"] = synthetic_y
 
     boxes_with_lines = assign_line_id(boxes_df, y_alignment="top")
-    
+
+    # Step 1b: Split the cells of single-row layout tables into their own lines
+    # (no-op, after one linear scan, on everything else).
+    boxes_with_lines, stacked = _split_layout_table_cell_lines(boxes_with_lines)
+
     # Step 2: Create text for each line (sorted by x_left, joined with spaces,
     # pipe-joined on table lines). Text is merged from the x-sorted view while
     # aggregation runs on the frame in document order, so "first"/dominant
     # columns keep picking the same source boxes as before.
-    line_text = _build_line_text(boxes_with_lines)
+    line_text = _build_line_text(boxes_with_lines, stacked=stacked)
 
     # Step 3: Aggregate everything else via the central column registry
     lines_df = aggregate_to(
@@ -406,6 +524,15 @@ def merge_boxes_to_lines(
     )
     lines_df["text"] = lines_df["line_id"].map(line_text)
 
+    # Sibling cells of one layout table share a layout group, so the columns stay
+    # in one layout after _remove_single_row_tables clears their table_id.
+    if stacked is not None:
+        split = boxes_with_lines.loc[stacked]
+        group = (
+            split["table_id"].astype(str) + ":" + split["table_row_id"].astype(str)
+        ).groupby(split["line_id"]).first()
+        lines_df["layout_cell_group"] = lines_df["line_id"].map(group)
+
     # Step 4: Remove single-row tables if requested
     if remove_single_row_tables:
         lines_df = _remove_single_row_tables(lines_df)

{docslicer-0.2.2 → docslicer-0.2.4}/src/docslicer/mcp/_store.py

@@ -16,6 +16,7 @@ import hashlib
 import json
 import os
 import re
+import sys
 import time
 from collections import OrderedDict
 from dataclasses import dataclass
@@ -47,10 +48,94 @@ def cache_limit_bytes() -> int:
     return max(0, megabytes) * 1024 * 1024
 
 
-def allowed_root() -> Path | None:
-    """Optional sandbox root. When DOCSLICER_MCP_ROOT is set, only files beneath it parse."""
-    env = os.environ.get("DOCSLICER_MCP_ROOT")
-    return Path(env).expanduser().resolve() if env else None
+def configured_roots() -> tuple[Path, ...]:
+    """The sandbox roots the operator named in DOCSLICER_MCP_ROOT.
+
+    More than one may be given, separated by the platform's path separator
+    (``:`` on macOS and Linux, ``;`` on Windows) — the same convention as PATH,
+    so a host that can only hand the server one string can still hand it
+    several directories. Empty when the variable is unset, which means no
+    sandbox at all.
+    """
+    env = os.environ.get("DOCSLICER_MCP_ROOT") or ""
+    parts = [p.strip() for p in env.split(os.pathsep)]
+    return tuple(Path(p).expanduser().resolve() for p in parts if p)
+
+
+def claude_dir_allowed() -> bool:
+    """Whether the Claude desktop app's data directory joins the sandbox. Disable with
+    DOCSLICER_MCP_ALLOW_CLAUDE_DIR=0."""
+    return os.environ.get("DOCSLICER_MCP_ALLOW_CLAUDE_DIR", "1").lower() not in (
+        "0",
+        "false",
+        "no",
+    )
+
+
+def claude_dir() -> Path | None:
+    """Where the Claude desktop app keeps its own files, or None if it is not there.
+
+    A document dropped into a Claude chat is not read from wherever the user
+    keeps it; the app copies it into a per-session workspace under this
+    directory and gives the model that path. So a root pointing at the user's
+    Documents or Desktop — the folder they would think to pick — matches none
+    of the files they actually hand the server, and every drop is refused as
+    outside the sandbox. This is the second root that makes the first usable.
+    """
+    if sys.platform == "darwin":
+        base = Path.home() / "Library" / "Application Support" / "Claude"
+    elif sys.platform == "win32":
+        appdata = os.environ.get("APPDATA")
+        if not appdata:
+            return None
+        base = Path(appdata) / "Claude"
+    else:
+        config = os.environ.get("XDG_CONFIG_HOME")
+        base = (Path(config) if config else Path.home() / ".config") / "Claude"
+
+    try:
+        resolved = base.expanduser().resolve(strict=True)
+    except OSError:
+        return None
+    return resolved if resolved.is_dir() else None
+
+
+def allowed_roots() -> tuple[Path, ...]:
+    """Every directory tree this server may read from and write to.
+
+    Empty means unrestricted. That is what an unset DOCSLICER_MCP_ROOT has
+    always meant, and the Claude directory is added only alongside a root the
+    operator set — a server told to sandbox nothing must not find itself
+    sandboxed to one directory because the app happens to be installed.
+    """
+    roots = configured_roots()
+    if not roots or not claude_dir_allowed():
+        return roots
+
+    extra = claude_dir()
+    if extra is None or any(_within(extra, root) for root in roots):
+        return roots
+    return roots + (extra,)
+
+
+def primary_root() -> Path | None:
+    """The root a path with nowhere else to go belongs in — the first one configured.
+
+    Only the operator's own roots qualify: the Claude directory is a place
+    files arrive from, not somewhere to file a document the caller asked for.
+    """
+    roots = configured_roots()
+    return roots[0] if roots else None
+
+
+def _within(path: Path, root: Path) -> bool:
+    """Whether a resolved path is the root or sits beneath it."""
+    return path == root or root in path.parents
+
+
+def _root_list(roots: tuple[Path, ...]) -> str:
+    """The allowed roots as an error message names them."""
+    return ", ".join(str(r) for r in roots)
 
 
 def urls_allowed() -> bool:
@@ -98,11 +183,11 @@ def resolve_source(source: str) -> str:
     except FileNotFoundError:
         raise FileNotFoundError(f"No such file: {source}") from None
 
-    root = allowed_root()
-    if root is not None and root not in resolved.parents and resolved != root:
+    roots = allowed_roots()
+    if roots and not any(_within(resolved, root) for root in roots):
         raise SourceNotAllowed(
-            f"Access to {resolved} is outside the allowed root {root}. "
-            "Copy the file inside that directory or adjust DOCSLICER_MCP_ROOT."
+            f"Access to {resolved} is outside the allowed roots: {_root_list(roots)}. "
+            "Copy the file inside one of those directories or adjust DOCSLICER_MCP_ROOT."
         )
     return str(resolved)
 
@@ -128,11 +213,11 @@ def resolve_output(path: str, base: Path | None = None) -> Path:
     anchor = base or Path.cwd()
     resolved = Path(target if target.is_absolute() else anchor / target).resolve()
 
-    root = allowed_root()
-    if root is not None and root not in resolved.parents:
+    roots = allowed_roots()
+    if roots and not any(root in resolved.parents for root in roots):
         raise SourceNotAllowed(
-            f"Cannot write to {resolved}: it is outside the allowed root {root}. "
-            "Choose an output_path inside that directory or adjust DOCSLICER_MCP_ROOT."
+            f"Cannot write to {resolved}: it is outside the allowed roots: {_root_list(roots)}. "
+            "Choose an output_path inside one of those directories or adjust DOCSLICER_MCP_ROOT."
         )
     return resolved