maybeai-sheet-cli 0.7.0__tar.gz → 0.8.0__tar.gz

{maybeai_sheet_cli-0.7.0 → maybeai_sheet_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maybeai-sheet-cli
-Version: 0.7.0
+Version: 0.8.0
 Summary: CLI for common MaybeAI spreadsheet operations
 Project-URL: Homepage, https://github.com/OmniMCP-AI/maybeai-sheet-cli
 Project-URL: Repository, https://github.com/OmniMCP-AI/maybeai-sheet-cli
@@ -167,6 +167,8 @@ Search, style, inspect history, and export:
 ```bash
 mbs excel-worksheet range search --doc-id abc123 --worksheet-name Sheet1 --query revenue --max-results 20
 mbs excel-worksheet style freeze-panes --doc-id abc123 --worksheet-name Sheet1 --cell B2
+mbs workbook calculate --doc-id abc123
+mbs excel-worksheet calculate --doc-id abc123 --worksheet-name Sheet1
 mbs excel-worksheet range calculate --doc-id abc123 --worksheet-name Sheet1 --cell E2 --formula "=SUM(B2:D2)"
 mbs version list --doc-id abc123 --limit 10
 mbs workbook export --doc-id abc123 --out workbook.xlsx
@@ -216,6 +218,7 @@ mbs
 │   ├── list-user-workbooks       API   List user workbooks with bounded output.
 |       list-worksheets           API   List worksheets, including engine.
 │   ├── search                   NOW   Search user workbooks with bounded output.
+│   ├── calculate                NOW   Recalculate formulas across the workbook.
 │   ├── export                   API   Export workbook bytes.
 │   └── copy                     API   Copy a workbook.
 │   ├── upload                   API   Upload a file through workbook import flow.
@@ -226,6 +229,7 @@ mbs
 │
 ├── excel_worksheet
 │   ├── read                     API   Read the full range of the worksheet.
+│   ├── calculate                NOW   Recalculate formulas in one worksheet.
 │   ├── list-table               API   Detect content-backed tables in a worksheet.
 │   ├── create                   API   Create a worksheet, optionally with starter values.
 │   ├── update                   API   Update worksheet metadata.
@@ -394,6 +398,8 @@ mbs excel-worksheet column append --doc-id abc123 --worksheet-name Actuals --val
 mbs excel-worksheet range lineage --doc-id abc123 --worksheet-name Model --cell E2 --format tree  # API
 
 # formula
+mbs workbook calculate --doc-id abc123  # API
+mbs excel-worksheet calculate --doc-id abc123 --worksheet-name Model  # API
 mbs excel-worksheet range calculate --doc-id abc123 --worksheet-name Model --cell E2 --formula "=SUM(B2:D2)"  # API
 mbs excel-worksheet range set-formula --doc-id abc123 --worksheet-name Model --cell E2 --formula "=SUM(B2:D2)"  # API
 

{maybeai_sheet_cli-0.7.0 → maybeai_sheet_cli-0.8.0}/README.md

@@ -143,6 +143,8 @@ Search, style, inspect history, and export:
 ```bash
 mbs excel-worksheet range search --doc-id abc123 --worksheet-name Sheet1 --query revenue --max-results 20
 mbs excel-worksheet style freeze-panes --doc-id abc123 --worksheet-name Sheet1 --cell B2
+mbs workbook calculate --doc-id abc123
+mbs excel-worksheet calculate --doc-id abc123 --worksheet-name Sheet1
 mbs excel-worksheet range calculate --doc-id abc123 --worksheet-name Sheet1 --cell E2 --formula "=SUM(B2:D2)"
 mbs version list --doc-id abc123 --limit 10
 mbs workbook export --doc-id abc123 --out workbook.xlsx
@@ -192,6 +194,7 @@ mbs
 │   ├── list-user-workbooks       API   List user workbooks with bounded output.
 |       list-worksheets           API   List worksheets, including engine.
 │   ├── search                   NOW   Search user workbooks with bounded output.
+│   ├── calculate                NOW   Recalculate formulas across the workbook.
 │   ├── export                   API   Export workbook bytes.
 │   └── copy                     API   Copy a workbook.
 │   ├── upload                   API   Upload a file through workbook import flow.
@@ -202,6 +205,7 @@ mbs
 │
 ├── excel_worksheet
 │   ├── read                     API   Read the full range of the worksheet.
+│   ├── calculate                NOW   Recalculate formulas in one worksheet.
 │   ├── list-table               API   Detect content-backed tables in a worksheet.
 │   ├── create                   API   Create a worksheet, optionally with starter values.
 │   ├── update                   API   Update worksheet metadata.
@@ -370,6 +374,8 @@ mbs excel-worksheet column append --doc-id abc123 --worksheet-name Actuals --val
 mbs excel-worksheet range lineage --doc-id abc123 --worksheet-name Model --cell E2 --format tree  # API
 
 # formula
+mbs workbook calculate --doc-id abc123  # API
+mbs excel-worksheet calculate --doc-id abc123 --worksheet-name Model  # API
 mbs excel-worksheet range calculate --doc-id abc123 --worksheet-name Model --cell E2 --formula "=SUM(B2:D2)"  # API
 mbs excel-worksheet range set-formula --doc-id abc123 --worksheet-name Model --cell E2 --formula "=SUM(B2:D2)"  # API
 

{maybeai_sheet_cli-0.7.0 → maybeai_sheet_cli-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "maybeai-sheet-cli"
-version = "0.7.0"
+version = "0.8.0"
 description = "CLI for common MaybeAI spreadsheet operations"
 readme = "README.md"
 requires-python = ">=3.10"

{maybeai_sheet_cli-0.7.0 → maybeai_sheet_cli-0.8.0}/src/maybeai_sheet/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.7.0"
+__version__ = "0.8.0"

{maybeai_sheet_cli-0.7.0 → maybeai_sheet_cli-0.8.0}/src/maybeai_sheet/commands/excel_worksheet.py

@@ -16,6 +16,7 @@ from ..table_resolver import filter_content_backed_excel_tables
 from .column import app as column_app
 from .range import app as range_app
 from .row import app as row_app
+from .sheet import recalculate as sheet_recalculate
 from .style import app as style_app
 from .worksheet import copy as worksheet_copy
 from .worksheet import create as worksheet_create
@@ -232,6 +233,49 @@ def move(
     )
 
 
+@app.command("calculate")
+def calculate(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved workbook URI."),
+    gid: Optional[int] = typer.Option(None, "--gid", help="Worksheet gid."),
+    worksheet_name: Optional[str] = typer.Option(None, "--worksheet-name", help="Worksheet name."),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    """Recalculate formulas in one worksheet."""
+    try:
+        if gid is not None and worksheet_name is None:
+            state = resolve_command_state(
+                ctx,
+                doc_id=doc_id,
+                url=url,
+                uri=uri,
+                gid=gid,
+                output=output,
+                verbose=verbose,
+                timeout=timeout,
+            )
+            target = resolve_target(state, force_gid_uri=True)
+            worksheet_name = target.worksheet_name
+            uri = target.uri
+            doc_id = target.document_id
+        sheet_recalculate(
+            ctx,
+            doc_id=doc_id,
+            url=url,
+            uri=uri,
+            worksheet_name=worksheet_name,
+            output=output,
+            verbose=verbose,
+            timeout=timeout,
+        )
+    except Exception as error:  # pragma: no cover - CLI boundary
+        handle_cli_error(error)
+
+
 app.add_typer(range_app, name="range")
 app.add_typer(row_app, name="row")
 app.add_typer(column_app, name="column")

{maybeai_sheet_cli-0.7.0 → maybeai_sheet_cli-0.8.0}/src/maybeai_sheet/commands/range.py

@@ -132,6 +132,7 @@ def search(
     verbose: Optional[bool] = verbose_option(),
     timeout: Optional[float] = timeout_option(),
 ) -> None:
+    """Search worksheet cells for text."""
     try:
         state = common_options(
             ctx,
@@ -161,3 +162,44 @@ def search(
         )
     except Exception as error:  # pragma: no cover - CLI boundary
         handle_cli_error(error)
+
+
+@app.command("calculate")
+def calculate(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved workbook URI."),
+    worksheet_name: Optional[str] = typer.Option(None, "--worksheet-name", help="Worksheet name."),
+    cell: str = typer.Option(..., "--cell", help="A1 cell address to calculate."),
+    formula: str = typer.Option(..., "--formula", help="Formula text to calculate."),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    """Calculate one formula expression for a worksheet cell."""
+    try:
+        state = common_options(
+            ctx,
+            doc_id=doc_id,
+            url=url,
+            uri=uri,
+            gid=None,
+            worksheet_name=worksheet_name,
+            output=output,
+            verbose=verbose,
+            timeout=timeout,
+        )
+        target = command_target(state)
+        require_worksheet(target)
+        payload = base_payload(target) | {"cellAddress": cell, "formula": formula}
+        run_post_command(
+            state=state,
+            endpoint="/api/v1/excel/calc-formula",
+            payload=payload,
+            target=target,
+            client_class=MaybeAIClient,
+            command_id="formula.calculate",
+        )
+    except Exception as error:  # pragma: no cover - CLI boundary
+        handle_cli_error(error)

{maybeai_sheet_cli-0.7.0 → maybeai_sheet_cli-0.8.0}/src/maybeai_sheet/commands/workbook.py

@@ -14,6 +14,7 @@ from ..models.workbook import CreateWorkbookRequest
 from ..options import output_option, resolve_command_state, timeout_option, verbose_option
 from ..resolver import ResolvedTarget, parse_document_target, resolve_target
 from ._phase2 import bounded_limit
+from .sheet import recalculate as sheet_recalculate
 
 app = typer.Typer(help="Workbook-level operations.", no_args_is_help=True)
 
@@ -252,6 +253,29 @@ def import_workbook(
     )
 
 
+@app.command("calculate")
+def calculate(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved workbook URI."),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    """Recalculate formulas across the workbook."""
+    sheet_recalculate(
+        ctx,
+        doc_id=doc_id,
+        url=url,
+        uri=uri,
+        worksheet_name=None,
+        output=output,
+        verbose=verbose,
+        timeout=timeout,
+    )
+
+
 @app.command("list")
 def list_workbooks(
     ctx: typer.Context,

maybeai_sheet_cli-0.8.0/tests/fixtures/benchmarks/build_fixtures.py

@@ -0,0 +1,213 @@
+"""Build deterministic XLSX and JSON fixtures for the mbs benchmark suite."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from zipfile import ZIP_DEFLATED, ZipFile
+
+
+ROOT = Path(__file__).resolve().parent
+
+
+def cell_ref(row: int, col: int) -> str:
+    letters = ""
+    while col:
+        col, rem = divmod(col - 1, 26)
+        letters = chr(65 + rem) + letters
+    return f"{letters}{row}"
+
+
+def cell_xml(row: int, col: int, value: object) -> str:
+    ref = cell_ref(row, col)
+    if value is None or value == "":
+        return f'<c r="{ref}"/>'
+    if isinstance(value, (int, float)):
+        return f'<c r="{ref}"><v>{value}</v></c>'
+    escaped = (
+        str(value)
+        .replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+    )
+    return f'<c r="{ref}" t="inlineStr"><is><t>{escaped}</t></is></c>'
+
+
+def sheet_xml(rows: list[list[object]]) -> str:
+    row_nodes = []
+    for row_idx, row in enumerate(rows, start=1):
+        cells = "".join(cell_xml(row_idx, col_idx, value) for col_idx, value in enumerate(row, start=1))
+        row_nodes.append(f'<row r="{row_idx}">{cells}</row>')
+    return (
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+        '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">'
+        f"<sheetData>{''.join(row_nodes)}</sheetData>"
+        "</worksheet>"
+    )
+
+
+def workbook_xml(sheet_names: list[str]) -> str:
+    sheets = "".join(
+        f'<sheet name="{name}" sheetId="{idx}" r:id="rId{idx}"/>'
+        for idx, name in enumerate(sheet_names, start=1)
+    )
+    return (
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+        '<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" '
+        'xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">'
+        f"<sheets>{sheets}</sheets>"
+        "</workbook>"
+    )
+
+
+def workbook_rels_xml(sheet_names: list[str]) -> str:
+    rels = "".join(
+        '<Relationship '
+        f'Id="rId{idx}" '
+        'Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" '
+        f'Target="worksheets/sheet{idx}.xml"/>'
+        for idx, _ in enumerate(sheet_names, start=1)
+    )
+    return (
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+        '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+        f"{rels}</Relationships>"
+    )
+
+
+def root_rels_xml() -> str:
+    return (
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+        '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+        '<Relationship Id="rId1" '
+        'Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" '
+        'Target="xl/workbook.xml"/>'
+        "</Relationships>"
+    )
+
+
+def content_types_xml(sheet_names: list[str]) -> str:
+    overrides = "".join(
+        '<Override '
+        f'PartName="/xl/worksheets/sheet{idx}.xml" '
+        'ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>'
+        for idx, _ in enumerate(sheet_names, start=1)
+    )
+    return (
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+        '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">'
+        '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>'
+        '<Default Extension="xml" ContentType="application/xml"/>'
+        '<Override PartName="/xl/workbook.xml" '
+        'ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>'
+        f"{overrides}</Types>"
+    )
+
+
+def write_xlsx(path: Path, sheets: dict[str, list[list[object]]]) -> None:
+    sheet_names = list(sheets)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with ZipFile(path, "w", ZIP_DEFLATED) as zf:
+        zf.writestr("[Content_Types].xml", content_types_xml(sheet_names))
+        zf.writestr("_rels/.rels", root_rels_xml())
+        zf.writestr("xl/workbook.xml", workbook_xml(sheet_names))
+        zf.writestr("xl/_rels/workbook.xml.rels", workbook_rels_xml(sheet_names))
+        for idx, name in enumerate(sheet_names, start=1):
+            zf.writestr(f"xl/worksheets/sheet{idx}.xml", sheet_xml(sheets[name]))
+
+
+def write_json(path: Path, data: object) -> None:
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def build(output_dir: Path = ROOT) -> list[Path]:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    created: list[Path] = []
+
+    simple_values = [
+        ["metric", "Q1", "Q2"],
+        ["revenue", 100, 120],
+        ["cost", 40, 55],
+    ]
+    rows = [
+        {"metric": "gross_profit", "Q1": 60, "Q2": 65},
+        {"metric": "margin", "Q1": "60%", "Q2": "54%"},
+    ]
+    write_json(output_dir / "simple-values.json", simple_values)
+    write_json(output_dir / "rows.json", rows)
+    created.extend([output_dir / "simple-values.json", output_dir / "rows.json"])
+
+    write_xlsx(
+        output_dir / "simple-grid.xlsx",
+        {
+            "BenchData": [
+                ["metric", "Q1", "Q2", "Q3"],
+                ["revenue", 100, 120, 140],
+                ["cost", 40, 55, 60],
+                ["profit", 60, 65, 80],
+            ]
+        },
+    )
+    created.append(output_dir / "simple-grid.xlsx")
+
+    write_xlsx(
+        output_dir / "flat-records.xlsx",
+        {
+            "Records": [
+                ["id", "customer", "amount", "status"],
+                [1, "Acme", 120.5, "paid"],
+                [2, "Beta", 340.0, "open"],
+                [3, "Core", 88.75, "paid"],
+                [4, "Delta", 901.1, "open"],
+            ]
+        },
+    )
+    created.append(output_dir / "flat-records.xlsx")
+
+    write_xlsx(
+        output_dir / "mixed-engine.xlsx",
+        {
+            "RecordsLarge": [
+                ["id", "amount", "status"],
+                *[[idx, idx * 3, "paid" if idx % 2 else "open"] for idx in range(1, 26)],
+            ],
+            "Cover": [["title", "Mixed engine fixture"], ["owner", "benchmark"]],
+            "Model": [["metric", "value"], ["revenue", 1200], ["cost", 700]],
+            "Events": [["event_id", "value"], [1, 20], [2, 22], [3, 25]],
+        },
+    )
+    created.append(output_dir / "mixed-engine.xlsx")
+
+    multi_table_rows = [
+        ["T01 Revenue Summary", "", "", "", ""],
+        ["", "", "", "", ""],
+        ["metric", "Q1", "Q2", "Q3", "total"],
+        ["revenue", 100, 120, 140, 360],
+        ["cost", 40, 55, 60, 155],
+        ["profit", 60, 65, 80, 205],
+        ["", "", "", "", ""],
+        ["", "", "", "", ""],
+        ["ratio", "Q1", "Q2", "Q3", "trend"],
+        ["margin", "60%", "54%", "57%", "up"],
+        ["cost_ratio", "40%", "46%", "43%", "down"],
+    ]
+    write_xlsx(output_dir / "multi-table-layout.xlsx", {"MultiTable": multi_table_rows})
+    created.append(output_dir / "multi-table-layout.xlsx")
+
+    return created
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-dir", type=Path, default=ROOT)
+    args = parser.parse_args()
+    created = build(args.output_dir)
+    for path in created:
+        print(path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

maybeai_sheet_cli-0.8.0/tests/fixtures/benchmarks/rows.json

@@ -0,0 +1,12 @@
+[
+  {
+    "metric": "gross_profit",
+    "Q1": 60,
+    "Q2": 65
+  },
+  {
+    "metric": "margin",
+    "Q1": "60%",
+    "Q2": "54%"
+  }
+]

maybeai_sheet_cli-0.8.0/tests/fixtures/benchmarks/simple-values.json

@@ -0,0 +1,17 @@
+[
+  [
+    "metric",
+    "Q1",
+    "Q2"
+  ],
+  [
+    "revenue",
+    100,
+    120
+  ],
+  [
+    "cost",
+    40,
+    55
+  ]
+]

maybeai_sheet_cli-0.8.0/tests/test_benchmark_runner.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+
+from scripts import benchmark_mbs_cli
+
+
+class BenchmarkRunnerTests(unittest.TestCase):
+    def test_case_catalog_has_exactly_50_ranked_cases(self) -> None:
+        cases = benchmark_mbs_cli.load_cases(benchmark_mbs_cli.DEFAULT_CASES)
+
+        self.assertEqual(len(cases), 50)
+        self.assertEqual([case["rank"] for case in cases], list(range(1, 51)))
+        self.assertEqual(cases[0]["case_id"], "001")
+        self.assertEqual(cases[-1]["case_id"], "050")
+
+    def test_dry_run_writes_summary_html_and_case_artifacts(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            report_root = Path(tmp)
+            result = subprocess.run(
+                [
+                    "./.venv/bin/python",
+                    "scripts/benchmark_mbs_cli.py",
+                    "--dry-run",
+                    "--no-publish-results",
+                    "--skip-fixture-build",
+                    "--run-id",
+                    "unit",
+                    "--rank-max",
+                    "2",
+                    "--report-root",
+                    str(report_root),
+                ],
+                text=True,
+                capture_output=True,
+                check=False,
+            )
+
+            self.assertEqual(result.returncode, 0, result.stderr)
+            run_dir = report_root / "mbs-cli-benchmark-unit"
+            self.assertTrue((run_dir / "summary.json").exists())
+            self.assertTrue((run_dir / "report.html").exists())
+            self.assertTrue((run_dir / "maybesheet_publish.json").exists())
+            self.assertTrue((run_dir / "cases" / "001-workbook-list-worksheets" / "verdict.json").exists())
+
+            summary = json.loads((run_dir / "summary.json").read_text(encoding="utf-8"))
+            self.assertEqual(summary["total"], 2)
+            self.assertEqual(summary["status"], "PASS")
+            self.assertEqual(summary["maybesheet"]["status"], "skipped")
+
+    def test_maybesheet_result_sheets_are_summary_details_and_html(self) -> None:
+        cases = benchmark_mbs_cli.load_cases(benchmark_mbs_cli.DEFAULT_CASES)[:2]
+        with tempfile.TemporaryDirectory() as tmp:
+            run_dir = Path(tmp) / "run"
+            run_dir.mkdir()
+            run = benchmark_mbs_cli.BenchmarkRun(
+                run_id="unit",
+                started_at="2026-07-02T00:00:00+00:00",
+                run_dir=run_dir,
+                mbs="./.venv/bin/mbs",
+                base_url=None,
+                context={"READ_DOC_ID": "doc1", "READ_TYPICAL_GID": "19"},
+            )
+            for case in cases:
+                case_dir = run_dir / "cases" / benchmark_mbs_cli.case_slug(case)
+                case_dir.mkdir(parents=True)
+                run.results.append(
+                    benchmark_mbs_cli.CaseResult(
+                        case=case,
+                        case_dir=case_dir,
+                        command=["mbs", *case["args"]],
+                        status="success",
+                        exit_code=0,
+                        duration_ms=10,
+                        response={"success": True},
+                        key_response={"success": True, "document_id": "doc1"},
+                        checks=[{"name": "exit_code", "pass": True}],
+                    )
+                )
+            summary = benchmark_mbs_cli.build_summary(run, 0, "0.7.0")
+            benchmark_mbs_cli.generate_html_report(run, summary)
+
+            sheets = benchmark_mbs_cli.build_result_sheets(run, summary)
+
+            self.assertEqual(list(sheets), ["Summary", "Details", "HTMLReport"])
+            self.assertEqual(len(sheets["Details"]), 3)
+            self.assertEqual(sheets["Details"][0][0], "rank")
+            self.assertEqual(sheets["HTMLReport"][0], ["section", "item", "value"])
+
+    def test_stdout_contains_check_and_key_response_capture(self) -> None:
+        result = benchmark_mbs_cli.CommandResult(
+            command=["mbs", "update", "--dry-run"],
+            exit_code=0,
+            stdout="python -m pip install --upgrade maybeai-sheet-cli==0.7.0\n",
+            stderr="",
+            duration_ms=5,
+        )
+
+        checks = benchmark_mbs_cli.evaluate_case_checks(
+            {
+                "expected_exit_code": 0,
+                "expected_json": False,
+                "expected_success": None,
+                "checks": [{"type": "stdout_contains", "value": "maybeai-sheet-cli==0.7.0"}],
+            },
+            result,
+            None,
+            {},
+            {},
+        )
+
+        self.assertTrue(all(check["pass"] for check in checks))
+
+    def test_case_env_unset_removes_proxy_for_command(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            script = Path(tmp) / "env_probe.py"
+            script.write_text(
+                "import os, sys\n"
+                "sys.stdout.write('missing' if 'ALL_PROXY' not in os.environ else os.environ['ALL_PROXY'])\n",
+                encoding="utf-8",
+            )
+            case = {
+                "rank": 1,
+                "case_id": "env",
+                "name": "env probe",
+                "category": "unit",
+                "args": [str(script)],
+                "expected_json": False,
+                "expected_success": None,
+                "env_unset": ["ALL_PROXY"],
+                "checks": [{"type": "stdout_contains", "value": "missing"}],
+            }
+            run_dir = Path(tmp) / "run"
+            run = benchmark_mbs_cli.BenchmarkRun(
+                run_id="unit",
+                started_at="2026-07-02T00:00:00+00:00",
+                run_dir=run_dir,
+                mbs="./.venv/bin/python",
+                base_url=None,
+                context={"RUN_DIR": str(run_dir)},
+            )
+
+            result = benchmark_mbs_cli.run_case(case, run, {"ALL_PROXY": "socks5://127.0.0.1:9"}, False)
+
+            self.assertEqual(result.status, "success")
+            self.assertEqual(result.stdout, "missing")
+
+
+if __name__ == "__main__":
+    unittest.main()

{maybeai_sheet_cli-0.7.0 → maybeai_sheet_cli-0.8.0}/tests/test_cli.py

@@ -1126,6 +1126,41 @@ class CLITests(unittest.TestCase):
         self.assertEqual(endpoint, "/api/v1/excel/recalculate_formulas")
         self.assertEqual(payload["worksheet_name"], "Model")
 
+    def test_workbook_calculate_recalculates_whole_workbook(self) -> None:
+        with patch("maybeai_sheet.commands.sheet.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"success": True}
+            result = self.runner.invoke(
+                app,
+                ["workbook", "calculate", "--doc-id", "abc123"],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, payload = post_json.call_args.args
+        self.assertEqual(endpoint, "/api/v1/excel/recalculate_formulas")
+        self.assertNotIn("worksheet_name", payload)
+
+    def test_excel_worksheet_calculate_recalculates_worksheet(self) -> None:
+        with patch("maybeai_sheet.commands.sheet.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"success": True}
+            result = self.runner.invoke(
+                app,
+                [
+                    "excel-worksheet",
+                    "calculate",
+                    "--doc-id",
+                    "abc123",
+                    "--worksheet-name",
+                    "Model",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, payload = post_json.call_args.args
+        self.assertEqual(endpoint, "/api/v1/excel/recalculate_formulas")
+        self.assertEqual(payload["worksheet_name"], "Model")
+
     def test_workbook_import_alias_uses_import_endpoint(self) -> None:
         with tempfile.NamedTemporaryFile(suffix=".xlsx") as temp_file:
             with patch("maybeai_sheet.commands.workbook.MaybeAIClient.upload_file") as upload_file:

{maybeai_sheet_cli-0.7.0 → maybeai_sheet_cli-0.8.0}/tests/test_phase2_cli.py

@@ -540,6 +540,34 @@ class Phase2CLITests(unittest.TestCase):
         self.assertEqual(lineage_payload["targets"], [{"worksheet_name": "Model", "cell": "E2"}])
         self.assertNotIn("compile", help_result.output)
 
+    def test_excel_worksheet_range_calculate_uses_formula_calculate_endpoint(self) -> None:
+        with patch("maybeai_sheet.commands.range.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"success": True}
+            result = self.runner.invoke(
+                app,
+                [
+                    "excel-worksheet",
+                    "range",
+                    "calculate",
+                    "--doc-id",
+                    "abc123",
+                    "--worksheet-name",
+                    "Model",
+                    "--cell",
+                    "E2",
+                    "--formula",
+                    "=SUM(B2:D2)",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, payload = post_json.call_args.args
+        self.assertEqual(endpoint, "/api/v1/excel/calc-formula")
+        self.assertEqual(payload["cellAddress"], "E2")
+        self.assertEqual(payload["formula"], "=SUM(B2:D2)")
+        self.assertEqual(payload["worksheet_name"], "Model")
+
     def test_cell_lineage_uses_verified_endpoint(self) -> None:
         with patch("maybeai_sheet.commands.cell.MaybeAIClient.post_json") as post_json:
             post_json.return_value = {"success": True}