ltcai 11.5.2 → 11.7.0

package/latticeai/tools/__init__.py

@@ -1,12 +1,21 @@
-"""Safe local tools for Lattice AI agent mode.
+"""The compute tool table — read-only tools, plus pointer actuation.
 
 All filesystem operations are confined to LATTICEAI_AGENT_ROOT, defaulting to
-./agent_workspace. Command execution runs without a shell and from inside that
-workspace.
-
-The physical implementation belongs to ``latticeai.tools``. The historical
-root ``tools`` package aliases this exact module object, preserving existing
-imports and ``tools.AGENT_ROOT`` monkeypatch/state identity.
+./agent_workspace.
+
+v11.6.0 §W4 moved the mutating half of this table into ``lattice-agent``: the
+file writes, the todo write, the project scaffold, the vault saves, the two
+desktop openers, the exec surface and the four document creators all run in the
+Rust loop's own sandbox now, and the creators call ``POST /worker/render/*``
+for the bytes. ``TOOL_HANDLERS`` is what a stateless worker may still be asked
+to do: **twenty-five** read-only / capability handlers, plus the **six** pointer
+tools the loop deliberately keeps sending here (v11.6.0 gateway integration
+§4b) because mouse and keyboard actuation is ``pyautogui`` — a capability of
+this interpreter, not a file write Rust can perform. A native refusal would
+only take working pointer control away from an install that has it.
+
+That is the whole seam: ``POST /agent/tool``'s whitelist is
+``registered_tools()``, and there is no second table.
 """
 
 import base64
@@ -162,20 +171,6 @@ from latticeai.tools.network import *  # noqa: E402,F401,F403
 
 
 # ── tool registry: the single name → invocation source of truth ───────────────
-def _h_create_xlsx(args: Dict[str, Any]) -> Dict[str, Any]:
-    rows = args.get("rows", [])
-    if isinstance(rows, str):
-        rows = json.loads(rows)
-    return create_xlsx(rows, args.get("filename", "spreadsheet.xlsx"), args.get("sheet_name", "Sheet1"))
-
-
-def _h_create_pptx(args: Dict[str, Any]) -> Dict[str, Any]:
-    slides = args.get("slides", [])
-    if isinstance(slides, str):
-        slides = json.loads(slides)
-    return create_pptx(args.get("title", ""), slides, args.get("filename", "presentation.pptx"))
-
-
 def _knowledge_scope(args: Dict[str, Any]) -> Dict[str, str]:
     """Return the authenticated scope injected by server/runtime adapters."""
     workspace_id = str(args.get("workspace_id") or "").strip()
@@ -197,31 +192,19 @@ TOOL_HANDLERS: Dict[str, Callable[[Dict[str, Any]], Dict[str, Any]]] = {
     "list_dir":          lambda a: list_dir(a.get("path", ".")),
     "workspace_tree":    lambda a: workspace_tree(a.get("path", "."), a.get("max_depth", 3)),
     "read_file":         lambda a: read_file(a["path"], offset=a.get("offset", 0), limit=a.get("limit", 0), line_numbers=a.get("line_numbers", True)),
-    "write_file":        lambda a: write_file(a["path"], a.get("content", "")),
-    "edit_file":         lambda a: edit_file(a["path"], a["old_string"], a["new_string"], replace_all=bool(a.get("replace_all", False))),
     "grep":              lambda a: grep(a["pattern"], path=a.get("path", "."), glob=a.get("glob"), max_results=a.get("max_results", 50), case_insensitive=bool(a.get("case_insensitive", False)), context_lines=a.get("context_lines", 0)),
     "search_files":      lambda a: search_files(a["query"], a.get("path", "."), a.get("max_results", 20)),
     "inspect_html":      lambda a: inspect_html(a["path"]),
     "preview_url":       lambda a: preview_url(a.get("path", "index.html")),
     # planning
     "todo_read":         lambda a: todo_read(),
-    "todo_write":        lambda a: todo_write(a.get("todos") or []),
-    # documents
-    "create_docx":       lambda a: create_docx(a.get("title", ""), a.get("body", ""), a.get("filename", "document.docx")),
-    "create_xlsx":       _h_create_xlsx,
-    "create_pptx":       _h_create_pptx,
-    "create_pdf":        lambda a: create_pdf(a.get("title", ""), a.get("body", ""), a.get("filename", "document.pdf")),
-    "create_web_project": lambda a: create_web_project(a.get("path", ""), a.get("framework", "react"), a.get("template", "vite")),
     # local filesystem
     "local_list":        lambda a: local_list(a["path"]),
     "local_read":        lambda a: local_read(a["path"]),
-    "local_write":       lambda a: local_write(a["path"], a.get("content", "")),
     "read_document":     lambda a: read_document(a["path"]),
     "network_status":    lambda a: network_status(),
     # computer use
     "computer_screenshot": lambda a: computer_screenshot(),
-    "computer_open_app": lambda a: computer_open_app(a.get("app", "Google Chrome")),
-    "computer_open_url": lambda a: computer_open_url(a["url"], a.get("app", "Google Chrome")),
     "computer_click":    lambda a: computer_click(a.get("x", 0), a.get("y", 0), a.get("button", "left"), a.get("double", False)),
     "computer_type":     lambda a: computer_type(a["text"], a.get("interval", 0.04)),
     "computer_key":      lambda a: computer_key(a["key"]),
@@ -233,10 +216,8 @@ TOOL_HANDLERS: Dict[str, Callable[[Dict[str, Any]], Dict[str, Any]]] = {
     "computer_use_status": lambda a: desktop_bridge_status(),
     "vision_analyze":    lambda a: vision_analyze(a.get("image_b64", ""), a.get("prompt", "Describe this image in detail. Be concise.")),
     # knowledge / obsidian
-    "knowledge_save":    lambda a: knowledge_save(a["content"], a.get("folder", "00_Raw"), a.get("title"), **_knowledge_scope(a)),
     "knowledge_search":  lambda a: knowledge_search(a["query"], a.get("max_results", 5), **_knowledge_scope(a)),
     "knowledge_tree":    lambda a: knowledge_tree(**_knowledge_scope(a)),
-    "obsidian_save":     lambda a: obsidian_save(a["content"], a.get("folder", "00_Raw"), a.get("title"), **_knowledge_scope(a)),
     "obsidian_search":   lambda a: obsidian_search(a["query"], a.get("max_results", 5), **_knowledge_scope(a)),
     "obsidian_tree":     lambda a: obsidian_tree(**_knowledge_scope(a)),
     # git (read-only)
@@ -244,10 +225,6 @@ TOOL_HANDLERS: Dict[str, Callable[[Dict[str, Any]], Dict[str, Any]]] = {
     "git_diff":          lambda a: git_diff(a.get("path"), a.get("cwd")),
     "git_log":           lambda a: git_log(a.get("max_count", 5), a.get("cwd")),
     "git_show":          lambda a: git_show(a.get("revision", "HEAD"), a.get("cwd")),
-    # exec
-    "run_command":       lambda a: run_command(a["command"], a.get("cwd")),
-    "build_project":     lambda a: build_project(a.get("cwd"), a.get("script", "build")),
-    "deploy_project":    lambda a: deploy_project(a.get("cwd"), a.get("script", "deploy")),
 }
 
 
@@ -265,19 +242,15 @@ def execute_tool(action: str, args: Dict[str, Any]) -> Dict[str, Any]:
 
 __all__ = [
     "AGENT_ROOT", "ToolError", "ensure_agent_root", "resolve_workspace_path",
-    "list_dir", "workspace_tree", "read_file", "write_file", "edit_file", "grep",
-    "search_files", "inspect_html", "preview_url", "create_web_project",
-    "todo_read", "todo_write",
-    "create_docx", "create_xlsx", "create_pptx", "create_pdf", "read_document",
+    "list_dir", "workspace_tree", "read_file", "grep",
+    "search_files", "inspect_html", "preview_url", "todo_read", "read_document",
     "document_output_target",
-    "local_list", "local_read", "local_write", "desktop_bridge_status",
-    "knowledge_save", "knowledge_search", "knowledge_tree", "knowledge_scope_root",
-    "obsidian_save", "obsidian_search", "obsidian_tree",
+    "local_list", "local_read", "desktop_bridge_status",
+    "knowledge_search", "knowledge_tree", "knowledge_scope_root",
+    "obsidian_search", "obsidian_tree",
     "network_status",
-    "computer_screenshot", "computer_open_app", "computer_open_url",
-    "computer_click", "computer_type", "computer_key", "computer_scroll",
+    "computer_screenshot", "computer_click", "computer_type", "computer_key", "computer_scroll",
     "computer_move", "computer_drag", "computer_status", "vision_analyze",
-    "run_command", "build_project", "deploy_project",
     "git_status", "git_diff", "git_log", "git_show",
     "TOOL_HANDLERS", "DEFAULT_TOOL_REGISTRY", "registered_tools", "execute_tool",
     "BRAIN_DIR", "STRUCTURE",

package/latticeai/tools/commands.py

@@ -2,28 +2,17 @@
 
 from __future__ import annotations
 
-import os
-import shlex
-import shutil
 import subprocess
-from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 import latticeai.tools as tools
 from latticeai.tools import (
-    ALLOWED_COMMANDS,
     ALLOWED_GIT_SUBCOMMANDS,
-    BLOCKED_COMMANDS,
-    BUILD_SCRIPT_NAMES,
-    DEPLOY_SCRIPT_NAMES,
-    MAX_BUILD_SECONDS,
     MAX_COMMAND_OUTPUT,
     MAX_COMMAND_SECONDS,
-    MAX_DEPLOY_SECONDS,
     ToolError,
     _relative,
     _resolve_path,
-    ensure_agent_root,
 )
 
 # find(1) flags that execute or delete; checked in run_command.
@@ -41,158 +30,6 @@ _BLOCKED_RG_FLAGS = {"--pre", "--pre-glob"}
 _SAFE_EXECUTABLE_PATH = "/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin:/usr/local/bin"
 
 
-def _argument_value(argument: str) -> str:
-    if argument.startswith("-") and "=" in argument:
-        return argument.split("=", 1)[1]
-    return argument
-
-
-def _validate_command_paths(parts: List[str], workdir: Path) -> None:
-    """Reject traversal and symlink escapes hidden in command arguments."""
-    for argument in parts[1:]:
-        value = _argument_value(argument)
-        if not value or value == "/dev/null" or (argument.startswith("-") and "=" not in argument):
-            continue
-        candidate_path = Path(value).expanduser()
-        if candidate_path.is_absolute():
-            raise ToolError(f"Absolute paths in command arguments are not allowed: {value}")
-        if ".." in candidate_path.parts:
-            raise ToolError(f"Path traversal in command arguments is not allowed: {value}")
-
-        candidate = workdir / candidate_path
-        # Existing arguments (including symlinks) and explicit path-shaped
-        # values must resolve inside the workspace. Other values can be search
-        # patterns, counts, or expressions and are not interpreted as paths.
-        if candidate.exists() or candidate.is_symlink() or "/" in value or "\\" in value:
-            resolved = candidate.resolve(strict=False)
-            if resolved != tools.AGENT_ROOT and tools.AGENT_ROOT not in resolved.parents:
-                raise ToolError(f"Path escapes the agent workspace: {value}")
-
-
-def run_command(command: str, cwd: Optional[str] = None) -> Dict[str, Any]:
-    ensure_agent_root()
-    parts = shlex.split(command)
-    if not parts:
-        raise ToolError("Command is empty.")
-
-    executable = Path(parts[0]).name
-    if parts[0] != executable:
-        raise ToolError("Executable paths are not allowed.")
-    if executable in BLOCKED_COMMANDS or executable not in ALLOWED_COMMANDS:
-        raise ToolError(f"Command is not allowed: {executable}")
-    if executable == "git":
-        raise ToolError("Use the read-only git_status, git_diff, git_log, or git_show tools.")
-    if any(token in command for token in ["|", "&&", "||", ";", ">", "<", "$(", "`"]):
-        raise ToolError("Shell operators are not allowed.")
-    if executable == "find":
-        blocked = [f for f in parts[1:] if f in _BLOCKED_FIND_FLAGS]
-        if blocked:
-            raise ToolError(f"find flags are not allowed: {', '.join(blocked)}")
-    if executable == "rg":
-        blocked = [
-            flag
-            for flag in parts[1:]
-            if any(flag == denied or flag.startswith(f"{denied}=") for denied in _BLOCKED_RG_FLAGS)
-        ]
-        if blocked:
-            raise ToolError(f"rg flags are not allowed: {', '.join(blocked)}")
-
-    workdir = _resolve_path(cwd or ".")
-    if not workdir.exists() or not workdir.is_dir():
-        raise ToolError("Working directory does not exist.")
-    _validate_command_paths(parts, workdir)
-
-    executable_path = shutil.which(executable, path=_SAFE_EXECUTABLE_PATH)
-    if not executable_path:
-        raise ToolError(f"Allowed command is not installed: {executable}")
-    environment = {
-        "HOME": str(tools.AGENT_ROOT),
-        "LANG": os.environ.get("LANG", "C.UTF-8"),
-        "LC_ALL": os.environ.get("LC_ALL", "C.UTF-8"),
-        "PATH": _SAFE_EXECUTABLE_PATH,
-    }
-
-    try:
-        completed = subprocess.run(
-            [executable_path, *parts[1:]],
-            cwd=workdir,
-            capture_output=True,
-            text=True,
-            env=environment,
-            timeout=MAX_COMMAND_SECONDS,
-            check=False,
-        )
-    except subprocess.TimeoutExpired:
-        raise ToolError(f"Command timed out after {MAX_COMMAND_SECONDS} seconds.")
-
-    stdout = completed.stdout[-MAX_COMMAND_OUTPUT:]
-    stderr = completed.stderr[-MAX_COMMAND_OUTPUT:]
-    return {
-        "command": command,
-        "cwd": _relative(workdir) if workdir != tools.AGENT_ROOT else ".",
-        "returncode": completed.returncode,
-        "stdout": stdout,
-        "stderr": stderr,
-    }
-
-
-def _load_package_scripts(workdir: Path) -> Dict[str, str]:
-    package_json = workdir / "package.json"
-    if not package_json.exists():
-        return {}
-    try:
-        import json
-        data = json.loads(package_json.read_text(encoding="utf-8"))
-    except Exception as exc:
-        raise ToolError(f"Could not parse package.json: {exc}") from exc
-    scripts = data.get("scripts") or {}
-    if not isinstance(scripts, dict):
-        return {}
-    return {str(key): str(value) for key, value in scripts.items()}
-
-
-def _run_script(script: str, cwd: Optional[str], allowed: set[str], timeout: int) -> Dict[str, Any]:
-    ensure_agent_root()
-    if script not in allowed:
-        raise ToolError(f"Script is not allowed here: {script}")
-    workdir = _resolve_path(cwd or ".")
-    if not workdir.exists() or not workdir.is_dir():
-        raise ToolError("Working directory does not exist.")
-
-    scripts = _load_package_scripts(workdir)
-    if script not in scripts:
-        raise ToolError(f"package.json does not define a '{script}' script.")
-
-    try:
-        completed = subprocess.run(
-            ["npm", "run", script],
-            cwd=workdir,
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-            check=False,
-        )
-    except subprocess.TimeoutExpired:
-        raise ToolError(f"npm run {script} timed out after {timeout} seconds.")
-
-    return {
-        "command": f"npm run {script}",
-        "cwd": _relative(workdir) if workdir != tools.AGENT_ROOT else ".",
-        "script_body": scripts[script],
-        "returncode": completed.returncode,
-        "stdout": completed.stdout[-MAX_COMMAND_OUTPUT:],
-        "stderr": completed.stderr[-MAX_COMMAND_OUTPUT:],
-    }
-
-
-def build_project(cwd: Optional[str] = None, script: str = "build") -> Dict[str, Any]:
-    return _run_script(script, cwd, BUILD_SCRIPT_NAMES, MAX_BUILD_SECONDS)
-
-
-def deploy_project(cwd: Optional[str] = None, script: str = "deploy") -> Dict[str, Any]:
-    return _run_script(script, cwd, DEPLOY_SCRIPT_NAMES, MAX_DEPLOY_SECONDS)
-
-
 def _run_git(args: List[str], cwd: Optional[str] = None) -> Dict[str, Any]:
     if not args:
         raise ToolError("Git subcommand is required.")

package/latticeai/tools/computer.py

@@ -72,45 +72,6 @@ def computer_screenshot() -> Dict[str, Any]:
             quiet()
 
 
-def computer_open_app(app: str = "Google Chrome") -> Dict[str, Any]:
-    """앱을 실행하거나 앞으로 가져옵니다 (macOS/Windows/Linux)."""
-    app = str(app or "Google Chrome").strip()
-    if not app:
-        raise ToolError("앱 이름이 필요합니다.")
-    if _PLATFORM == "Darwin":
-        cmd = ["open", "-a", app]
-    elif _PLATFORM == "Windows":
-        cmd = ["cmd", "/c", "start", "", app]
-    else:
-        cmd = ["xdg-open", app]
-    r = subprocess.run(cmd, capture_output=True, timeout=10, check=False)
-    if r.returncode != 0:
-        err = r.stderr.decode("utf-8", errors="replace").strip()
-        raise ToolError(f"앱 열기 실패: {err or app}")
-    return {"action": "open_app", "app": app}
-
-
-def computer_open_url(url: str, app: str = "Google Chrome") -> Dict[str, Any]:
-    """URL을 브라우저로 엽니다 (macOS/Windows/Linux)."""
-    url = str(url or "").strip()
-    app = str(app or "").strip()
-    if not url:
-        raise ToolError("URL이 필요합니다.")
-    if "://" not in url and not url.startswith(("localhost", "127.0.0.1")):
-        url = "https://" + url
-    if _PLATFORM == "Darwin":
-        cmd = ["open", "-a", app, url] if app else ["open", url]
-    elif _PLATFORM == "Windows":
-        cmd = ["cmd", "/c", "start", "", url]
-    else:
-        cmd = ["xdg-open", url]
-    r = subprocess.run(cmd, capture_output=True, timeout=10, check=False)
-    if r.returncode != 0:
-        err = r.stderr.decode("utf-8", errors="replace").strip()
-        raise ToolError(f"URL 열기 실패: {err or url}")
-    return {"action": "open_url", "app": app or "default", "url": url}
-
-
 def computer_click(x: int, y: int, button: str = "left", double: bool = False) -> Dict[str, Any]:
     """화면 좌표 (x, y)를 클릭합니다."""
     if not _CU_AVAILABLE:

package/latticeai/tools/documents.py

@@ -3,11 +3,9 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple
 
-from latticeai.core.quiet import quiet
 from latticeai.tools import (
-    _CJK_FONT_CANDIDATES,
     _SUPPORTED_READ_EXTENSIONS,
     DOCUMENT_MAX_READ_BYTES,
     DOCUMENT_OUTPUT_DIR,
@@ -15,8 +13,6 @@ from latticeai.tools import (
     PRESENTATION_OUTPUT_DIR,
     SPREADSHEET_OUTPUT_DIR,
     ToolError,
-    _relative,
-    _resolve_path,
 )
 
 
@@ -57,141 +53,12 @@ def document_output_target(tool_name: str, filename: str) -> Optional[str]:
     return f"{output_dir}/{_safe_filename(filename, suffix)}"
 
 
-def _document_target(tool_name: str, filename: str) -> Path:
-    """Resolved, workspace-confined target for a document creator."""
-    relative = document_output_target(tool_name, filename)
-    if relative is None:  # pragma: no cover — every creator is in the table
-        raise ToolError(f"'{tool_name}' has no document output target.")
-    target = _resolve_path(relative)
-    target.parent.mkdir(parents=True, exist_ok=True)
-    return target
-
-
 def _body_to_str(body) -> str:
     if isinstance(body, list):
         return "\n\n".join(str(item) for item in body)
     return str(body or "")
 
 
-def create_docx(title: str, body, filename: str = "document.docx") -> Dict[str, Any]:
-    try:
-        from docx import Document
-    except Exception as exc:
-        raise ToolError("python-docx is not installed. Run `pip install -r requirements.txt`.") from exc
-
-    target = _document_target("create_docx", filename)
-
-    document = Document()
-    if title:
-        document.add_heading(str(title), level=1)
-    for block in _body_to_str(body).split("\n\n"):
-        text = block.strip()
-        if text:
-            document.add_paragraph(text)
-    document.save(str(target))
-    return {"path": _relative(target), "bytes": target.stat().st_size}
-
-
-def create_xlsx(rows: List[List[Any]], filename: str = "spreadsheet.xlsx", sheet_name: str = "Sheet1") -> Dict[str, Any]:
-    try:
-        from openpyxl import Workbook
-    except Exception as exc:
-        raise ToolError("openpyxl is not installed. Run `pip install -r requirements.txt`.") from exc
-
-    if not isinstance(rows, list) or not all(isinstance(row, list) for row in rows):
-        raise ToolError("Rows must be a list of lists.")
-
-    target = _document_target("create_xlsx", filename)
-
-    workbook = Workbook()
-    sheet = workbook.active
-    sheet.title = (sheet_name or "Sheet1")[:31]
-    for row in rows:
-        sheet.append(row)
-    workbook.save(target)
-    return {"path": _relative(target), "rows": len(rows), "bytes": target.stat().st_size}
-
-
-def create_pptx(title: str, slides: List[Dict[str, Any]], filename: str = "presentation.pptx") -> Dict[str, Any]:
-    try:
-        from pptx import Presentation
-    except Exception as exc:
-        raise ToolError("python-pptx is not installed. Run `pip install -r requirements.txt`.") from exc
-
-    target = _document_target("create_pptx", filename)
-
-    presentation = Presentation()
-    first_layout = presentation.slide_layouts[0]
-    first = presentation.slides.add_slide(first_layout)
-    first.shapes.title.text = title or "Presentation"
-    first.placeholders[1].text = ""
-
-    content_layout = presentation.slide_layouts[1]
-    for slide_data in slides or []:
-        slide = presentation.slides.add_slide(content_layout)
-        slide.shapes.title.text = str(slide_data.get("title") or "Slide")
-        body = slide.placeholders[1].text_frame
-        body.clear()
-        bullets = slide_data.get("bullets") or []
-        if isinstance(bullets, str):
-            bullets = [bullets]
-        for index, bullet in enumerate(bullets):
-            paragraph = body.paragraphs[0] if index == 0 else body.add_paragraph()
-            paragraph.text = str(bullet)
-            paragraph.level = 0
-
-    presentation.save(str(target))
-    return {"path": _relative(target), "slides": len(presentation.slides), "bytes": target.stat().st_size}
-
-
-
-
-def create_pdf(title: str, body, filename: str = "document.pdf") -> Dict[str, Any]:
-    try:
-        from reportlab.lib.pagesizes import A4
-        from reportlab.lib.styles import ParagraphStyle
-        from reportlab.lib.units import mm
-        from reportlab.pdfbase import pdfmetrics
-        from reportlab.pdfbase.ttfonts import TTFont
-        from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer
-    except Exception as exc:
-        raise ToolError("reportlab is not installed. Run `pip install reportlab`.") from exc
-
-    target = _document_target("create_pdf", filename)
-
-    # CJK 폰트 등록
-    font_name = "Helvetica"
-    for font_path in _CJK_FONT_CANDIDATES:
-        if Path(font_path).exists():
-            try:
-                pdfmetrics.registerFont(TTFont("KoreanFont", font_path))
-                font_name = "KoreanFont"
-            except Exception:
-                quiet()
-            break
-
-    title_style = ParagraphStyle("Title", fontName=font_name, fontSize=18, spaceAfter=8, leading=24)
-    body_style  = ParagraphStyle("Body",  fontName=font_name, fontSize=11, spaceAfter=6, leading=16)
-
-    story = []
-    if title:
-        story.append(Paragraph(str(title), title_style))
-        story.append(Spacer(1, 4 * mm))
-
-    for block in _body_to_str(body).split("\n\n"):
-        text = block.strip()
-        if text:
-            safe_text = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-            story.append(Paragraph(safe_text, body_style))
-            story.append(Spacer(1, 2 * mm))
-
-    doc = SimpleDocTemplate(str(target), pagesize=A4,
-                             leftMargin=20*mm, rightMargin=20*mm,
-                             topMargin=20*mm, bottomMargin=20*mm)
-    doc.build(story)
-    return {"path": _relative(target), "bytes": target.stat().st_size}
-
-
 def read_document(path: str) -> Dict[str, Any]:
     """Extract text from PDF, DOCX, XLSX, PPTX, TXT, MD, CSV files."""
     target = Path(path).expanduser().resolve()