licos-dev-cli 0.4.1__tar.gz → 0.4.3__tar.gz

{licos_dev_cli-0.4.1 → licos_dev_cli-0.4.3}/.gitignore

@@ -34,6 +34,8 @@ crates/industrial/industrial-stack.env
 *.log
 *.pid
 .licos
+# Keep project template metadata in version control.
+!/tools/licos-ai-cli/lib/__templates__/*/.licos
 .tmp
 .playwright-cli
 
@@ -41,6 +43,8 @@ crates/industrial/industrial-stack.env
 crates/industrial/bin/
 
 tools/android-sdk-cache/*.zip
+tools/android-sdk-cache/*.tar.xz
+tools/android-sdk-cache/*.tar.gz
 tools/codegraph-cache/*.tgz
 tools/codegraph-cache/*.tgz
 

{licos_dev_cli-0.4.1 → licos_dev_cli-0.4.3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: licos-dev-cli
-Version: 0.4.1
+Version: 0.4.3
 Summary: LICOS Dev CLI - generate files and call model capabilities
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1
-Requires-Dist: licos-dev-sdk>=0.4.1
+Requires-Dist: licos-dev-sdk>=0.4.3

{licos_dev_cli-0.4.1 → licos_dev_cli-0.4.3}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-cli"
-version = "0.4.1"
+version = "0.4.3"
 description = "LICOS Dev CLI - generate files and call model capabilities"
 requires-python = ">=3.10"
 dependencies = [
-    "licos-dev-sdk>=0.4.1",
+    "licos-dev-sdk>=0.4.3",
     "click>=8.1",
 ]
 

licos_dev_cli-0.4.3/src/licos_dev_cli/common.py

@@ -0,0 +1,85 @@
+"""Shared CLI input and output helpers."""
+
+from __future__ import annotations
+
+import sys
+import json
+import os
+from pathlib import Path
+import click
+
+def _read_input(input_path: str | None, content: str | None) -> str:
+    """Read content from --input file, --content arg, or stdin."""
+    if input_path:
+        with open(input_path, "r", encoding="utf-8") as f:
+            return f.read()
+    if content:
+        return content
+    if not sys.stdin.isatty():
+        return sys.stdin.read()
+    raise click.UsageError("Provide --input, --content, or pipe via stdin.")
+
+
+def _read_json(input_path: str | None, content: str | None) -> object:
+    """Read and parse JSON from input."""
+    raw = _read_input(input_path, content)
+    return json.loads(raw)
+
+
+def _json_option(value: str | None, name: str) -> dict | list | None:
+    if not value:
+        return None
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError as exc:
+        raise click.BadParameter(f"{name} must be valid JSON") from exc
+
+
+def _echo_json(value: object) -> None:
+    if hasattr(value, "to_dict"):
+        value = value.to_dict()
+    click.echo(json.dumps(value, ensure_ascii=False, indent=2))
+
+
+def _path_to_cli_output(path: object) -> str:
+    raw = str(path)
+    if not raw:
+        return raw
+
+    normalized = raw.replace("\\", "/")
+    string_roots = [
+        os.environ.get("LICOS_PROJECT_PATH"),
+        (os.path.join(os.environ["LICOS_WORKSPACE_PATH"], "projects") if os.environ.get("LICOS_WORKSPACE_PATH") else None),
+        "/workspace/projects",
+    ]
+    for root in string_roots:
+        if not root:
+            continue
+        prefix = root.replace("\\", "/").rstrip("/")
+        if normalized == prefix:
+            return "."
+        if normalized.startswith(f"{prefix}/"):
+            return normalized[len(prefix) + 1 :]
+
+    p = Path(raw)
+    if not p.is_absolute():
+        return normalized
+
+    path_roots = [
+        os.environ.get("LICOS_PROJECT_PATH"),
+        (os.path.join(os.environ["LICOS_WORKSPACE_PATH"], "projects") if os.environ.get("LICOS_WORKSPACE_PATH") else None),
+        str(Path.cwd()),
+    ]
+    for root in path_roots:
+        if not root:
+            continue
+        try:
+            return p.resolve().relative_to(Path(root).resolve()).as_posix()
+        except (OSError, RuntimeError, ValueError):
+            continue
+
+    return normalized
+
+
+def _echo_path(path: object) -> None:
+    click.echo(_path_to_cli_output(path))

licos_dev_cli-0.4.3/src/licos_dev_cli/docx_commands.py

@@ -0,0 +1,187 @@
+"""Focused Word commands; all document operations are implemented by the SDK."""
+
+from functools import wraps
+import json
+from pathlib import Path
+from zipfile import BadZipFile
+
+import click
+
+from .common import _echo_json, _path_to_cli_output
+from .docx_legacy import docx, docx_template, docx_edit, docx_read
+
+
+def sdk_errors(function):
+    @wraps(function)
+    def invoke(*args, **kwargs):
+        try:
+            return function(*args, **kwargs)
+        except (ValueError, TypeError, OSError, BadZipFile) as exc:
+            raise click.ClickException(str(exc)) from exc
+    return invoke
+
+
+def result(report):
+    report["path"] = _path_to_cli_output(report["path"])
+    _echo_json(report)
+
+
+def target_options(function):
+    for name in ("paragraph", "block", "table", "row", "column"):
+        function = click.option("--" + name, type=click.IntRange(min=1), help="Use the exact target returned by docx-structure/docx-read.")(function)
+    return function
+
+
+def target(paragraph, block, table, row, column):
+    return {key: value for key, value in locals().items() if value is not None}
+
+
+def edit_options(function):
+    for decorator in (
+        click.option("--source", required=True, type=click.Path(exists=True, dir_okay=False)),
+        click.option("--output", required=True, help="Output .docx path."),
+        click.option("--revision", required=True, help="Revision from the latest read of this source; edits return a new revision."),
+        click.option("--overwrite", is_flag=True, help="Explicitly allow replacing an existing output."),
+    ):
+        function = decorator(function)
+    return function
+
+
+def text_input(value, path, name):
+    if (value is None) == (path is None):
+        raise click.UsageError(f"provide exactly one of --{name} and --{name}-file")
+    return Path(path).read_text(encoding="utf-8") if path is not None else value
+
+
+@click.command("docx-structure")
+@click.option("--file", "source", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--scope", type=click.Choice(["blocks", "paragraphs", "tables"]), default="blocks", show_default=True)
+@click.option("--offset", type=click.IntRange(min=1), default=1, show_default=True)
+@click.option("--limit", type=click.IntRange(1, 200), default=20, show_default=True)
+@click.option("--max-chars", type=click.IntRange(1, 8000), default=200, show_default=True)
+@sdk_errors
+def docx_structure(**arguments):
+    """Read revision and paginated targets. Paragraph indices include table paragraphs.
+
+    Use docx-target to continue reading a truncated target. Do not convert block
+    indices into paragraph indices.
+    """
+    from licos_dev_sdk import read_docx_structure
+    result(read_docx_structure(**arguments))
+
+
+@click.command("docx-target")
+@click.option("--file", "source", required=True, type=click.Path(exists=True, dir_okay=False))
+@target_options
+@click.option("--text-offset", type=click.IntRange(min=0), default=0, show_default=True)
+@click.option("--max-chars", type=click.IntRange(1, 30000), default=8000, show_default=True)
+@sdk_errors
+def docx_target(source, paragraph, block, table, row, column, **arguments):
+    """Read one block, paragraph, or table+row+column. Continue with next_text_offset."""
+    from licos_dev_sdk import read_docx_target
+    result(read_docx_target(source, target(paragraph, block, table, row, column), **arguments))
+
+
+@click.command("docx-replace")
+@edit_options
+@target_options
+@click.option("--search", required=True, help="Exact original text; must match once in the target.")
+@click.option("--replace", "replacement", default=None, help="Replacement text; use --replace-file for long text.")
+@click.option("--replace-file", type=click.Path(exists=True, dir_okay=False))
+@sdk_errors
+def docx_replace(paragraph, block, table, row, column, replacement, replace_file, **arguments):
+    """Replace text at an exact target, preserving surrounding runs and formatting."""
+    from licos_dev_sdk import replace_docx_text
+    result(replace_docx_text(target=target(paragraph, block, table, row, column),
+                            replacement=text_input(replacement, replace_file, "replace"), **arguments))
+
+
+@click.command("docx-delete-blocks")
+@edit_options
+@click.option("--from", "first", required=True, type=click.IntRange(min=1))
+@click.option("--to", "last", required=True, type=click.IntRange(min=1))
+@sdk_errors
+def docx_delete_blocks(**arguments):
+    """Delete an inclusive body block range from one revision; preserve section layout."""
+    from licos_dev_sdk import delete_docx_blocks
+    result(delete_docx_blocks(**arguments))
+
+
+@click.command("docx-edit-structure")
+@edit_options
+@click.option("--input", "input_path", required=True, type=click.Path(exists=True, dir_okay=False), help="JSON array of 1-200 operations; use small batches.")
+@sdk_errors
+def docx_edit_structure(input_path, **arguments):
+    """Apply a small batch against one revision. Array entries are:
+
+    {"op":"replace_text","target":{"paragraph":1},"search":"old","replace":"new"}
+
+    {"op":"delete_blocks","from":3,"to":4}
+
+    All targets refer to the same input snapshot. Use a returned target unchanged.
+    """
+    from licos_dev_sdk import edit_docx_structure
+    result(edit_docx_structure(operations=json.loads(Path(input_path).read_text(encoding="utf-8")), **arguments))
+
+
+@click.command("docx-table-set")
+@edit_options
+@click.option("--table", required=True, type=click.IntRange(min=1))
+@click.option("--row", required=True, type=click.IntRange(min=1))
+@click.option("--column", required=True, type=click.IntRange(min=1))
+@click.option("--text", default=None)
+@click.option("--text-file", type=click.Path(exists=True, dir_okay=False))
+@sdk_errors
+def docx_table_set(text, text_file, **arguments):
+    """Fill one cell at its logical anchor, preserving cell and template text styles."""
+    from licos_dev_sdk import set_docx_cell
+    result(set_docx_cell(text=text_input(text, text_file, "text"), **arguments))
+
+
+@click.command("docx-table-insert-rows")
+@edit_options
+@click.option("--table", required=True, type=click.IntRange(min=1))
+@click.option("--before", type=click.IntRange(min=1), help="Insert before this one-based row. Choose --before or --append.")
+@click.option("--append", is_flag=True, help="Append after the last row; no row count calculation needed.")
+@click.option("--template-row", required=True, type=click.IntRange(min=1), help="Existing styled row; must not intersect a vertical merge.")
+@click.option("--input", "input_path", required=True, type=click.Path(exists=True, dir_okay=False), help="Two-dimensional JSON array of scalar values. Fill a merged cell once; count is inferred.")
+@sdk_errors
+def docx_table_insert_rows(input_path, **arguments):
+    """Clone styled template rows and fill values. No action, count or operations wrapper."""
+    from licos_dev_sdk import insert_docx_rows
+    result(insert_docx_rows(rows=json.loads(Path(input_path).read_text(encoding="utf-8")), **arguments))
+
+
+@click.command("docx-verify")
+@click.option("--file", "source", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--original", type=click.Path(exists=True, dir_okay=False), help="Compare non-body package parts (headers, footers, styles, images) and section settings with the original.")
+@click.option("--input", "input_path", type=click.Path(exists=True, dir_okay=False), help="JSON array of target/text assertions and optional mode (equals, contains, absent).")
+@target_options
+@click.option("--text", default=None, help="Expected text at one target; use this or --text-file instead of --input.")
+@click.option("--text-file", type=click.Path(exists=True, dir_okay=False), help="UTF-8 expected text; preserves whitespace and line breaks.")
+@click.option("--mode", type=click.Choice(["equals", "contains", "absent"]), help="Single-target comparison; defaults to equals.")
+@sdk_errors
+def docx_verify(source, original, input_path, paragraph, block, table, row, column, text, text_file, mode):
+    """Verify exact positions and optional original parts. No assertions means no content verification.
+
+    Example: [{"target":{"table":1,"row":1,"column":1},"text":"Supplier: A"}]
+
+    Exits 2 if an assertion or original comparison fails. Does not certify rendered page layout.
+    """
+    from licos_dev_sdk import verify_docx
+    position = target(paragraph, block, table, row, column)
+    single = bool(position) or text is not None or text_file is not None or mode is not None
+    if input_path is not None and single:
+        raise click.UsageError("use --input or a single target with --text/--text-file, not both")
+    expectations = json.loads(Path(input_path).read_text(encoding="utf-8")) if input_path else None
+    if single:
+        expectations = [{"target": position, "text": text_input(text, text_file, "text"), "mode": mode or "equals"}]
+    report = verify_docx(source, original=original, expectations=expectations)
+    result(report)
+    if not report["verified"]:
+        raise click.exceptions.Exit(2)
+
+
+DOCX_COMMANDS = [docx, docx_template, docx_edit, docx_read, docx_structure, docx_target,
+                 docx_replace, docx_delete_blocks, docx_edit_structure, docx_table_set,
+                 docx_table_insert_rows, docx_verify]

licos_dev_cli-0.4.3/src/licos_dev_cli/docx_legacy.py

@@ -0,0 +1,95 @@
+"""Existing DOCX CLI entry points backed by the SDK."""
+
+from pathlib import Path
+import click
+from .common import _read_input, _read_json, _echo_path, _path_to_cli_output, _echo_json
+
+# ── DOCX ─────────────────────────────────────────────────────────────────────
+
+@click.command("docx")
+@click.option("-i", "--input", "input_path")
+@click.option("-c", "--content")
+@click.option("-f", "--filename", required=True)
+@click.option("-o", "--output-dir", default=None)
+@click.option("--format", "content_type", default="markdown")
+@click.option("--font", default="Microsoft YaHei")
+@click.option("--font-size", default=11, type=int)
+@click.option("--theme", default="formal-blue", help="Theme: formal-blue|business|neutral")
+@click.option("--title", default=None, help="Document title used when content has no H1")
+@click.option("--header", default=None, help="Header text")
+@click.option("--footer", default=None, help="Footer text placed before the page number")
+@click.option("--toc/--no-toc", default=False, help="Insert an updatable Word table of contents")
+def docx(input_path, content, filename, output_dir, content_type, font, font_size, theme, title, header, footer, toc):
+    """Generate DOCX from Markdown or HTML."""
+    from licos_dev_sdk import create_docx
+    text = _read_input(input_path, content)
+    path = create_docx(
+        text,
+        filename,
+        content_type=content_type,
+        output_dir=output_dir,
+        font_name=font,
+        font_size=font_size,
+        theme=theme,
+        title=title,
+        header=header,
+        footer=footer,
+        include_toc=toc,
+        asset_base_path=str(Path(input_path).resolve().parent) if input_path else None,
+    )
+    _echo_path(path)
+
+
+@click.command("docx-template")
+@click.option("-t", "--template", "template_path", required=True, help="DOCX template path")
+@click.option("-i", "--input", "input_path", help="JSON data file")
+@click.option("-d", "--data", "data_content", help="JSON data")
+@click.option("-f", "--filename", required=True)
+@click.option("-o", "--output-dir", default=None)
+def docx_template(template_path, input_path, data_content, filename, output_dir):
+    """Generate DOCX by rendering a DOCX template with JSON data."""
+    from licos_dev_sdk import create_docx_from_template
+    data = _read_json(input_path, data_content)
+    if not isinstance(data, dict):
+        raise click.BadParameter("template data must be a JSON object")
+    path = create_docx_from_template(template_path, data, filename, output_dir=output_dir)
+    _echo_path(path)
+
+
+@click.command("docx-edit")
+@click.option("-s", "--source", "source_path", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("-i", "--input", "input_path", help="JSON operation file")
+@click.option("-d", "--data", "data_content", help="JSON operation array")
+@click.option("-f", "--filename", required=True)
+@click.option("-o", "--output-dir", default=None)
+def docx_edit(source_path, input_path, data_content, filename, output_dir):
+    """Edit native tables in an existing DOCX package."""
+    from licos_dev_sdk import edit_docx
+
+    payload = _read_json(input_path, data_content)
+    operations = payload.get("operations") if isinstance(payload, dict) else payload
+    if not isinstance(operations, list):
+        raise click.BadParameter("operations must be a JSON array or an object containing operations")
+    path = edit_docx(source_path, operations, filename, output_dir=output_dir)
+    _echo_path(path)
+
+
+@click.command("docx-read")
+@click.option("-f", "--file", "file_path", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--offset", type=click.IntRange(min=1), default=1, show_default=True)
+@click.option("--limit", type=click.IntRange(min=1), default=20, show_default=True)
+@click.option("--max-chars", type=click.IntRange(min=256), default=8_000, show_default=True)
+@click.option("--include-styles", is_flag=True, help="Include paragraph, run, row, and cell styles")
+def docx_read(file_path, offset, limit, max_chars, include_styles):
+    """Read DOCX paragraphs and table rows as paginated JSON."""
+    from licos_dev_sdk import read_docx
+
+    report = read_docx(
+        file_path,
+        offset=offset,
+        limit=limit,
+        max_chars=max_chars,
+        include_styles=include_styles,
+    )
+    report["path"] = _path_to_cli_output(report["path"])
+    _echo_json(report)

{licos_dev_cli-0.4.1 → licos_dev_cli-0.4.3}/src/licos_dev_cli/main.py

@@ -2,102 +2,27 @@
 
 from __future__ import annotations
 
-import sys
 import json
-import os
 from pathlib import Path
 import click
 
 from .ppt_master import ppt_master
-
-# ── Helpers ──────────────────────────────────────────────────────────────────
-
-def _read_input(input_path: str | None, content: str | None) -> str:
-    """Read content from --input file, --content arg, or stdin."""
-    if input_path:
-        with open(input_path, "r", encoding="utf-8") as f:
-            return f.read()
-    if content:
-        return content
-    if not sys.stdin.isatty():
-        return sys.stdin.read()
-    raise click.UsageError("Provide --input, --content, or pipe via stdin.")
-
-
-def _read_json(input_path: str | None, content: str | None) -> object:
-    """Read and parse JSON from input."""
-    raw = _read_input(input_path, content)
-    return json.loads(raw)
-
-
-def _json_option(value: str | None, name: str) -> dict | list | None:
-    if not value:
-        return None
-    try:
-        return json.loads(value)
-    except json.JSONDecodeError as exc:
-        raise click.BadParameter(f"{name} must be valid JSON") from exc
-
-
-def _echo_json(value: object) -> None:
-    if hasattr(value, "to_dict"):
-        value = value.to_dict()
-    click.echo(json.dumps(value, ensure_ascii=False, indent=2))
-
-
-def _path_to_cli_output(path: object) -> str:
-    raw = str(path)
-    if not raw:
-        return raw
-
-    normalized = raw.replace("\\", "/")
-    string_roots = [
-        os.environ.get("LICOS_PROJECT_PATH"),
-        (os.path.join(os.environ["LICOS_WORKSPACE_PATH"], "projects") if os.environ.get("LICOS_WORKSPACE_PATH") else None),
-        "/workspace/projects",
-    ]
-    for root in string_roots:
-        if not root:
-            continue
-        prefix = root.replace("\\", "/").rstrip("/")
-        if normalized == prefix:
-            return "."
-        if normalized.startswith(f"{prefix}/"):
-            return normalized[len(prefix) + 1 :]
-
-    p = Path(raw)
-    if not p.is_absolute():
-        return normalized
-
-    path_roots = [
-        os.environ.get("LICOS_PROJECT_PATH"),
-        (os.path.join(os.environ["LICOS_WORKSPACE_PATH"], "projects") if os.environ.get("LICOS_WORKSPACE_PATH") else None),
-        str(Path.cwd()),
-    ]
-    for root in path_roots:
-        if not root:
-            continue
-        try:
-            return p.resolve().relative_to(Path(root).resolve()).as_posix()
-        except (OSError, RuntimeError, ValueError):
-            continue
-
-    return normalized
-
-
-def _echo_path(path: object) -> None:
-    click.echo(_path_to_cli_output(path))
+from .docx_commands import DOCX_COMMANDS
+from .common import _read_input, _read_json, _json_option, _echo_json, _path_to_cli_output, _echo_path
 
 
 # ── CLI Group ────────────────────────────────────────────────────────────────
 
 @click.group()
+@click.version_option(package_name="licos-dev-cli")
 def cli():
     """LICOS Dev - file generation and model CLI for AI agents."""
     pass
 
 
 cli.add_command(ppt_master)
+for command in DOCX_COMMANDS:
+    cli.add_command(command)
 
 
 @cli.command("credit-check")
@@ -199,97 +124,6 @@ def pdf_read(file_path, offset, limit, max_chars):
     _echo_json(report)
 
 
-# ── DOCX ─────────────────────────────────────────────────────────────────────
-
-@cli.command()
-@click.option("-i", "--input", "input_path")
-@click.option("-c", "--content")
-@click.option("-f", "--filename", required=True)
-@click.option("-o", "--output-dir", default=None)
-@click.option("--format", "content_type", default="markdown")
-@click.option("--font", default="Microsoft YaHei")
-@click.option("--font-size", default=11, type=int)
-@click.option("--theme", default="formal-blue", help="Theme: formal-blue|business|neutral")
-@click.option("--title", default=None, help="Document title used when content has no H1")
-@click.option("--header", default=None, help="Header text")
-@click.option("--footer", default=None, help="Footer text placed before the page number")
-@click.option("--toc/--no-toc", default=False, help="Insert an updatable Word table of contents")
-def docx(input_path, content, filename, output_dir, content_type, font, font_size, theme, title, header, footer, toc):
-    """Generate DOCX from Markdown or HTML."""
-    from licos_dev_sdk import create_docx
-    text = _read_input(input_path, content)
-    path = create_docx(
-        text,
-        filename,
-        content_type=content_type,
-        output_dir=output_dir,
-        font_name=font,
-        font_size=font_size,
-        theme=theme,
-        title=title,
-        header=header,
-        footer=footer,
-        include_toc=toc,
-        asset_base_path=str(Path(input_path).resolve().parent) if input_path else None,
-    )
-    _echo_path(path)
-
-
-@cli.command("docx-template")
-@click.option("-t", "--template", "template_path", required=True, help="DOCX template path")
-@click.option("-i", "--input", "input_path", help="JSON data file")
-@click.option("-d", "--data", "data_content", help="JSON data")
-@click.option("-f", "--filename", required=True)
-@click.option("-o", "--output-dir", default=None)
-def docx_template(template_path, input_path, data_content, filename, output_dir):
-    """Generate DOCX by rendering a DOCX template with JSON data."""
-    from licos_dev_sdk import create_docx_from_template
-    data = _read_json(input_path, data_content)
-    if not isinstance(data, dict):
-        raise click.BadParameter("template data must be a JSON object")
-    path = create_docx_from_template(template_path, data, filename, output_dir=output_dir)
-    _echo_path(path)
-
-
-@cli.command("docx-edit")
-@click.option("-s", "--source", "source_path", required=True, type=click.Path(exists=True, dir_okay=False))
-@click.option("-i", "--input", "input_path", help="JSON operation file")
-@click.option("-d", "--data", "data_content", help="JSON operation array")
-@click.option("-f", "--filename", required=True)
-@click.option("-o", "--output-dir", default=None)
-def docx_edit(source_path, input_path, data_content, filename, output_dir):
-    """Edit native tables in an existing DOCX package."""
-    from licos_dev_sdk import edit_docx
-
-    payload = _read_json(input_path, data_content)
-    operations = payload.get("operations") if isinstance(payload, dict) else payload
-    if not isinstance(operations, list):
-        raise click.BadParameter("operations must be a JSON array or an object containing operations")
-    path = edit_docx(source_path, operations, filename, output_dir=output_dir)
-    _echo_path(path)
-
-
-@cli.command("docx-read")
-@click.option("-f", "--file", "file_path", required=True, type=click.Path(exists=True, dir_okay=False))
-@click.option("--offset", type=click.IntRange(min=1), default=1, show_default=True)
-@click.option("--limit", type=click.IntRange(min=1), default=20, show_default=True)
-@click.option("--max-chars", type=click.IntRange(min=256), default=8_000, show_default=True)
-@click.option("--include-styles", is_flag=True, help="Include paragraph, run, row, and cell styles")
-def docx_read(file_path, offset, limit, max_chars, include_styles):
-    """Read DOCX paragraphs and table rows as paginated JSON."""
-    from licos_dev_sdk import read_docx
-
-    report = read_docx(
-        file_path,
-        offset=offset,
-        limit=limit,
-        max_chars=max_chars,
-        include_styles=include_styles,
-    )
-    report["path"] = _path_to_cli_output(report["path"])
-    _echo_json(report)
-
-
 # ── XLSX ─────────────────────────────────────────────────────────────────────
 
 @cli.command()

licos_dev_cli-0.4.3/tests/test_docx_commands.py

@@ -0,0 +1,126 @@
+import json
+
+from click.testing import CliRunner
+from docx import Document
+import pytest
+
+from licos_dev_cli.main import cli
+
+
+@pytest.fixture
+def source(tmp_path):
+    path = tmp_path / "input.docx"
+    doc = Document()
+    doc.add_paragraph("账号：123")
+    doc.add_paragraph("附录")
+    doc.add_table(rows=1, cols=2).cell(0, 0).text = "模板"
+    doc.save(path)
+    return path
+
+
+def invoke(*arguments):
+    result = CliRunner().invoke(cli, list(map(str, arguments)))
+    assert result.exit_code == 0, result.output or repr(result.exception)
+    return json.loads(result.output)
+
+
+def test_focused_commands_complete_read_replace_delete_and_verify(source, tmp_path):
+    read = invoke("docx-structure", "--file", source)
+    output = tmp_path / "filled.docx"
+    edited = invoke("docx-replace", "--source", source, "--output", output, "--revision", read["revision"],
+                     "--block", "1", "--search", "123", "--replace", "456")
+    deleted = invoke("docx-delete-blocks", "--source", output, "--output", output, "--overwrite", "--revision", edited["revision"], "--from", "2", "--to", "2")
+    assert deleted["revision"] != edited["revision"]
+    assertions = tmp_path / "assertions.json"
+    assertions.write_text(json.dumps([{"target": {"block": 1}, "text": "账号：456"}]), encoding="utf-8")
+    assert invoke("docx-verify", "--file", output, "--input", assertions)["content_verified"]
+    assertions.write_text('[{"target":{"block":1},"text":"wrong"}]', encoding="utf-8")
+    failure = CliRunner().invoke(cli, ["docx-verify", "--file", str(output), "--input", str(assertions)])
+    assert failure.exit_code == 2
+    assert json.loads(failure.output)["mismatches"]
+
+
+def test_file_input_and_continuation_keep_long_text_out_of_shell_arguments(source, tmp_path):
+    replacement = tmp_path / "replacement.txt"
+    replacement.write_text("长文\n" * 100, encoding="utf-8")
+    output = tmp_path / "long.docx"
+    revision = invoke("docx-structure", "--file", source)["revision"]
+    invoke("docx-replace", "--source", source, "--output", output, "--revision", revision,
+           "--paragraph", 1, "--search", "123", "--replace-file", replacement)
+    first = invoke("docx-target", "--file", output, "--paragraph", 1, "--max-chars", 17)
+    second = invoke("docx-target", "--file", output, "--paragraph", 1, "--max-chars", 17, "--text-offset", first["next_text_offset"])
+    assert first["text"] + second["text"] == Document(output).paragraphs[0].text[:34]
+
+
+def test_insert_rows_needs_no_action_or_count_wrapper(source, tmp_path):
+    rows = tmp_path / "rows.json"
+    rows.write_text('[["pump",2],["valve",3]]', encoding="utf-8")
+    output = tmp_path / "rows.docx"
+    revision = invoke("docx-structure", "--file", source)["revision"]
+    result = invoke("docx-table-insert-rows", "--source", source, "--output", output, "--revision", revision,
+                    "--table", 1, "--before", 2, "--template-row", 1, "--input", rows)
+    assert result["inserted_rows"] == 2
+    assert Document(output).tables[0].cell(2, 0).text == "valve"
+
+
+def test_bad_revision_reports_original_error_and_leaves_output_absent(source, tmp_path):
+    output = tmp_path / "bad.docx"
+    result = CliRunner().invoke(cli, ["docx-delete-blocks", "--source", str(source), "--output", str(output),
+                                      "--revision", "outdated", "--from", "2", "--to", "2"])
+    assert result.exit_code != 0
+    assert "revision changed" in result.output
+    assert not output.exists()
+
+
+def test_command_help_is_focused_and_preserves_constraints():
+    runner = CliRunner()
+    for name in ("docx-structure", "docx-target", "docx-replace", "docx-delete-blocks", "docx-edit-structure",
+                 "docx-table-set", "docx-table-insert-rows", "docx-verify"):
+        help_text = runner.invoke(cli, [name, "--help"])
+        assert help_text.exit_code == 0
+        assert len(help_text.output.encode("utf-8")) < 5000
+    help_text = runner.invoke(cli, ["docx-table-insert-rows", "--help"]).output
+    assert "--revision" in help_text and "--template-row" in help_text and "--count" not in help_text
+
+
+def test_append_and_verify_with_original_and_text_file(source, tmp_path):
+    rows = tmp_path / "rows.json"
+    rows.write_text('[["pump",2]]', encoding="utf-8")
+    output = tmp_path / "rows.docx"
+    read = invoke("docx-structure", "--file", source, "--scope", "tables")
+    assert read["items"][0]["row_count"] == 1
+    invoke("docx-table-insert-rows", "--source", source, "--output", output, "--revision", read["revision"],
+           "--table", 1, "--append", "--template-row", 1, "--input", rows)
+    assert invoke("docx-verify", "--file", output, "--original", source, "--table", 1, "--row", 2, "--column", 1, "--text", "pump")["verified"]
+    replacement = tmp_path / "text.txt"
+    text = "  中文🙂\t空格\n" * 100 + "  "
+    replacement.write_text(text, encoding="utf-8")
+    invoke("docx-replace", "--source", output, "--output", output, "--overwrite",
+           "--revision", invoke("docx-structure", "--file", output)["revision"],
+           "--block", 1, "--search", "账号：123", "--replace-file", replacement)
+    verified = invoke("docx-verify", "--file", output, "--original", source, "--block", 1, "--text-file", replacement)
+    assert verified["content_verified"] and verified["preservation_verified"]
+
+
+@pytest.mark.parametrize("arguments", [
+    ["--block", "1"], ["--text", "x"], ["--mode", "contains"],
+    ["--block", "1", "--text", "x", "--input", "checks.json"],
+    ["--block", "1", "--text", "x", "--text-file", "text.txt"],
+])
+def test_invalid_verification_options_are_reported(source, tmp_path, monkeypatch, arguments):
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "checks.json").write_text("[]", encoding="utf-8")
+    (tmp_path / "text.txt").write_text("x", encoding="utf-8")
+    result = CliRunner().invoke(cli, ["docx-verify", "--file", str(source), *arguments])
+    assert result.exit_code != 0
+    assert "Error:" in result.output
+
+
+def test_original_comparison_failure_exits_two(source, tmp_path):
+    changed = tmp_path / "changed.docx"
+    doc = Document(source)
+    doc.sections[0].footer.paragraphs[0].text = "changed footer"
+    doc.save(changed)
+    failure = CliRunner().invoke(cli, ["docx-verify", "--file", str(changed), "--original", str(source)])
+    assert failure.exit_code == 2
+    assert not json.loads(failure.output)["preservation_verified"]