maybeai-sheet-cli 0.13.2__tar.gz → 0.14.0__tar.gz

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maybeai-sheet-cli
-Version: 0.13.2
+Version: 0.14.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
@@ -293,6 +293,7 @@ mbs
 ├── db_worksheet(AKA db_table)
 │   ├── create                 API    Create a PG-backed table from JSON row data.
 │   ├── create-from-query      API    Calculate SQL and create a PG-backed table from tabular results.
+│   ├── create-from-range      API    Read a source worksheet range and create a PG-backed table on a target workbook.
 │   ├── update                 PLAN   Update PG-backed rows from JSON row data.
 │   ├── delete                 PLAN   Delete PG-backed rows/table; requires --yes unless --dry-run.
 │   ├── schema                 API    Infer table schema from a bounded PG read.
@@ -410,6 +411,7 @@ mbs db-table read --doc-id abc123 --name orders-large --limit 100 --offset 200
 mbs db-table insert --doc-id abc123 --name orders-large --rows rows.json  # API
 mbs db-table create --doc-id abc123 --name Orders --rows orders.json  # API
 mbs db-table create-from-query --doc-id abc123 --name OrderSummary --sql-file order_summary.sql  # API
+mbs db-table create-from-range --doc-id target123 --name R_OrderLines_Store1 --source-doc-id source123 --worksheet-name "1店" --range A2:AR423 --header-row 0 --use-header-names --if-exists adopt --verify  # API
 mbs db-table update --doc-id abc123 --name Orders --key order_id --rows orders_patch.json  # PLAN
 mbs db-table update --doc-id abc123 --name Orders --row-index 42 --rows row_patch.json  # PLAN
 mbs db-table update --doc-id abc123 --name Orders --where '{"status":"open"}' --rows status_patch.json  # PLAN
@@ -502,8 +504,10 @@ mbs share create --doc-id abc123 --email teammate@example.com --role viewer  # A
 limit is 100 rows, and `--limit` / `--offset` are capped at 10,000 to avoid
 accidental large PG scans. `db-table create-from-query` is CLI-composed: it
 calculates a tabular `=SQL(...)` result through `calc-formula`, then creates a
-PG/SheetTable-backed table through `db_table/create`. Use a keyset-style backend
-contract for deeper pagination when it becomes available.
+PG/SheetTable-backed table through `db_table/create`. `db-table create-from-range`
+is also CLI-composed: it reads a source worksheet range, reshapes header/data
+rows, then creates a PG/SheetTable on the target workbook. Use a keyset-style
+backend contract for deeper pagination when it becomes available.
 
 Refactor planning is tracked separately from this README:
 `docs/superpowers/plans/2026-07-01-mbs-two-engine-command-refactor.md`.

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/README.md

@@ -269,6 +269,7 @@ mbs
 ├── db_worksheet(AKA db_table)
 │   ├── create                 API    Create a PG-backed table from JSON row data.
 │   ├── create-from-query      API    Calculate SQL and create a PG-backed table from tabular results.
+│   ├── create-from-range      API    Read a source worksheet range and create a PG-backed table on a target workbook.
 │   ├── update                 PLAN   Update PG-backed rows from JSON row data.
 │   ├── delete                 PLAN   Delete PG-backed rows/table; requires --yes unless --dry-run.
 │   ├── schema                 API    Infer table schema from a bounded PG read.
@@ -386,6 +387,7 @@ mbs db-table read --doc-id abc123 --name orders-large --limit 100 --offset 200
 mbs db-table insert --doc-id abc123 --name orders-large --rows rows.json  # API
 mbs db-table create --doc-id abc123 --name Orders --rows orders.json  # API
 mbs db-table create-from-query --doc-id abc123 --name OrderSummary --sql-file order_summary.sql  # API
+mbs db-table create-from-range --doc-id target123 --name R_OrderLines_Store1 --source-doc-id source123 --worksheet-name "1店" --range A2:AR423 --header-row 0 --use-header-names --if-exists adopt --verify  # API
 mbs db-table update --doc-id abc123 --name Orders --key order_id --rows orders_patch.json  # PLAN
 mbs db-table update --doc-id abc123 --name Orders --row-index 42 --rows row_patch.json  # PLAN
 mbs db-table update --doc-id abc123 --name Orders --where '{"status":"open"}' --rows status_patch.json  # PLAN
@@ -478,8 +480,10 @@ mbs share create --doc-id abc123 --email teammate@example.com --role viewer  # A
 limit is 100 rows, and `--limit` / `--offset` are capped at 10,000 to avoid
 accidental large PG scans. `db-table create-from-query` is CLI-composed: it
 calculates a tabular `=SQL(...)` result through `calc-formula`, then creates a
-PG/SheetTable-backed table through `db_table/create`. Use a keyset-style backend
-contract for deeper pagination when it becomes available.
+PG/SheetTable-backed table through `db_table/create`. `db-table create-from-range`
+is also CLI-composed: it reads a source worksheet range, reshapes header/data
+rows, then creates a PG/SheetTable on the target workbook. Use a keyset-style
+backend contract for deeper pagination when it becomes available.
 
 Refactor planning is tracked separately from this README:
 `docs/superpowers/plans/2026-07-01-mbs-two-engine-command-refactor.md`.

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/pyproject.toml

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

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/src/maybeai_sheet/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.13.2"
+__version__ = "0.14.0"

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/src/maybeai_sheet/commands/db_table.py

@@ -12,7 +12,13 @@ from ..endpoints import get_endpoint_metadata
 from ..errors import APIRequestError, UsageError
 from ..formatters import build_command_output, handle_cli_error, load_json_file, render_output
 from ..options import output_option, resolve_command_state, timeout_option, verbose_option
-from ..resolver import ResolvedTarget, append_gid, parse_document_target, resolve_target
+from ..resolver import (
+    ResolvedTarget,
+    append_gid,
+    build_document_url,
+    parse_document_target,
+    resolve_target,
+)
 from ..table_resolver import (
     ResolvedTableTarget,
     bounded_a1_range,
@@ -176,6 +182,148 @@ def _load_query(sql: str | None, sql_file: Path | None) -> str:
     return sql if sql is not None else sql_file.read_text()
 
 
+def _positional_column_name(index: int) -> str:
+    return f"raw_col_{index + 1:03d}"
+
+
+def _header_fallback_column_name(index: int) -> str:
+    return f"col_{index + 1:03d}"
+
+
+def _values_matrix_from_read_response(response: dict[str, Any]) -> list[list[Any]]:
+    for key in ("values", "data", "rows"):
+        candidate = response.get(key)
+        if isinstance(candidate, list) and (
+            not candidate or all(isinstance(row, list) for row in candidate)
+        ):
+            return [list(row) if isinstance(row, list) else [] for row in candidate]
+    raise UsageError("Source range readback did not contain a values matrix.")
+
+
+def _unique_column_names(names: list[str]) -> list[str]:
+    seen: dict[str, int] = {}
+    unique: list[str] = []
+    for name in names:
+        count = seen.get(name, 0)
+        seen[name] = count + 1
+        unique.append(name if count == 0 else f"{name}_{count + 1}")
+    return unique
+
+
+def _is_blank_matrix_row(row: list[Any]) -> bool:
+    if not row:
+        return True
+    return all(value is None or str(value).strip() == "" for value in row)
+
+
+def _surface_from_values_matrix(
+    values: list[list[Any]],
+    *,
+    header_row: int = 0,
+    use_header_names: bool = False,
+    data_start: int | None = None,
+    data_end: int | None = None,
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]], dict[str, Any]]:
+    if not values:
+        raise UsageError("Source range readback is empty.")
+    if header_row < 0:
+        raise UsageError("--header-row must be at least 0.")
+    if header_row >= len(values):
+        raise UsageError(f"--header-row {header_row} is out of range (total={len(values)}).")
+
+    resolved_data_start = header_row + 1 if data_start is None else data_start
+    resolved_data_end = len(values) if data_end is None else data_end
+    if resolved_data_start < 0:
+        raise UsageError("--data-start must be at least 0.")
+    if resolved_data_end < resolved_data_start:
+        raise UsageError("--data-end must be greater than or equal to --data-start.")
+    if resolved_data_end > len(values):
+        raise UsageError(f"--data-end {resolved_data_end} is out of range (total={len(values)}).")
+
+    header_cells = list(values[header_row] or [])
+    width = len(header_cells)
+    for row in values[resolved_data_start:resolved_data_end]:
+        if isinstance(row, list):
+            width = max(width, len(row))
+    if width == 0:
+        raise UsageError("Source range header row did not contain any columns.")
+
+    while len(header_cells) < width:
+        header_cells.append(None)
+
+    if use_header_names:
+        raw_names = [
+            str(cell or "").strip() or _header_fallback_column_name(index)
+            for index, cell in enumerate(header_cells)
+        ]
+        column_names = _unique_column_names(raw_names)
+    else:
+        column_names = [_positional_column_name(index) for index in range(width)]
+
+    rows: list[dict[str, Any]] = []
+    dropped_blank = 0
+    for raw_row in values[resolved_data_start:resolved_data_end]:
+        cells = list(raw_row) if isinstance(raw_row, list) else []
+        if _is_blank_matrix_row(cells):
+            dropped_blank += 1
+            continue
+        row: dict[str, Any] = {}
+        for index, name in enumerate(column_names):
+            value = cells[index] if index < len(cells) else None
+            row[name] = "" if value is None else value
+        rows.append(row)
+
+    columns = [
+        {
+            "name": name,
+            "logical_type": "text",
+            "index": index,
+        }
+        for index, name in enumerate(column_names)
+    ]
+    summary = {
+        "header_row": header_row,
+        "use_header_names": use_header_names,
+        "data_start": resolved_data_start,
+        "data_end": resolved_data_end,
+        "column_count": len(columns),
+        "row_count": len(rows),
+        "rows_dropped_blank": dropped_blank,
+        "column_names": column_names,
+    }
+    return columns, rows, summary
+
+
+def _resolve_source_workbook_target(
+    *,
+    source_doc_id: str | None,
+    source_url: str | None,
+    worksheet_name: str,
+) -> ResolvedTarget:
+    if bool(source_doc_id) == bool(source_url):
+        raise UsageError("Provide exactly one of --source-doc-id or --source-url.")
+    if source_url:
+        document_id, _gid = parse_document_target(source_url)
+        if not document_id:
+            raise UsageError("--source-url must include a MaybeAI document id.")
+        return ResolvedTarget(
+            document_id=document_id,
+            url=source_url,
+            uri=source_url,
+            gid=None,
+            worksheet_name=worksheet_name,
+        )
+    assert source_doc_id is not None
+    uri = build_document_url(source_doc_id)
+    return ResolvedTarget(
+        document_id=source_doc_id,
+        url=uri,
+        uri=uri,
+        gid=None,
+        worksheet_name=worksheet_name,
+    )
+
+
 def _first_tabular_value(value: Any) -> Any:
     if isinstance(value, list):
         if not value:
@@ -885,6 +1033,174 @@ def create_from_query(
         handle_cli_error(error)
 
 
+DB_TABLE_CREATE_FROM_RANGE_EXAMPLE = """Example:
+
+  mbs db-table create-from-range \\
+    --doc-id <target_doc_id> \\
+    --name R_OrderLines_Store1 \\
+    --source-doc-id <source_doc_id> \\
+    --worksheet-name "1店" \\
+    --range A2:AR423 \\
+    --header-row 0 \\
+    --use-header-names \\
+    --if-exists adopt \\
+    --verify \\
+    --output json
+
+Reads a source worksheet range, treats --header-row as a 0-based index inside
+the returned values matrix, drops blank rows, and creates a PG/SheetTable on
+the target --doc-id. Use --use-header-names for semantic headers (merged-title
+sheets); omit it for positional raw_col_NNN columns.
+"""
+
+
+@app.command(
+    "create-from-range",
+    help="Create a PG/SheetTable-backed table from a source worksheet range readback.",
+    epilog=DB_TABLE_CREATE_FROM_RANGE_EXAMPLE,
+)
+def create_from_range(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="Target MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="Target MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved target workbook URI."),
+    name: str = typer.Option(..., "--name", help="New PG-backed table name on the target workbook."),
+    source_doc_id: Optional[str] = typer.Option(
+        None,
+        "--source-doc-id",
+        help="Source MaybeAI document ID to read the range from.",
+    ),
+    source_url: Optional[str] = typer.Option(
+        None,
+        "--source-url",
+        help="Source MaybeAI workbook URL to read the range from.",
+    ),
+    worksheet_name: str = typer.Option(
+        ...,
+        "--worksheet-name",
+        help="Source worksheet name to read.",
+    ),
+    cell_range: str = typer.Option(
+        ...,
+        "--range",
+        help="Source A1-style range to read (include the semantic header row).",
+    ),
+    header_row: int = typer.Option(
+        0,
+        "--header-row",
+        min=0,
+        help="0-based header row index inside the returned values matrix (not an Excel row number).",
+    ),
+    use_header_names: bool = typer.Option(
+        False,
+        "--use-header-names",
+        help="Use header cell text as column names; blank cells become col_NNN. Default uses raw_col_NNN.",
+    ),
+    data_start: Optional[int] = typer.Option(
+        None,
+        "--data-start",
+        min=0,
+        help="Optional 0-based data start index inside the values matrix; defaults to header-row+1.",
+    ),
+    data_end: Optional[int] = typer.Option(
+        None,
+        "--data-end",
+        min=0,
+        help="Optional 0-based exclusive data end index inside the values matrix; defaults to end.",
+    ),
+    if_exists: str = typer.Option("error", "--if-exists", help="Existing table policy: error or adopt."),
+    adopt_existing: bool = typer.Option(False, "--adopt-existing", help="Alias for --if-exists adopt."),
+    verify: bool = typer.Option(False, "--verify", help="Verify PG registry state after create/adopt."),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    try:
+        policy = "adopt" if adopt_existing else if_exists.strip().lower()
+        if policy not in {"error", "adopt"}:
+            raise UsageError("--if-exists must be 'error' or 'adopt'.")
+        state = _state(
+            ctx,
+            doc_id=doc_id,
+            url=url,
+            uri=uri,
+            output=output,
+            verbose=verbose,
+            timeout=timeout,
+        )
+        target_workbook = resolve_target(state)
+        source_workbook = _resolve_source_workbook_target(
+            source_doc_id=source_doc_id,
+            source_url=source_url,
+            worksheet_name=worksheet_name,
+        )
+        client = MaybeAIClient(state)
+        read_endpoint = "/api/v1/excel/read_sheet"
+        read_payload = {
+            "uri": source_workbook.uri,
+            "worksheet_name": worksheet_name,
+            "range_address": cell_range,
+            "value_render_option": "FORMATTED_VALUE",
+        }
+        read_response = client.post_json(read_endpoint, read_payload)
+        values = _values_matrix_from_read_response(read_response)
+        loaded_columns, loaded_rows, surface_summary = _surface_from_values_matrix(
+            values,
+            header_row=header_row,
+            use_header_names=use_header_names,
+            data_start=data_start,
+            data_end=data_end,
+        )
+        create_endpoint = "/api/v1/excel/db_table/create"
+        create_payload = {
+            "document_id": target_workbook.document_id,
+            "uri": target_workbook.uri,
+            "name": name,
+            "columns": loaded_columns,
+            "rows": loaded_rows,
+            "if_exists": policy,
+        }
+        try:
+            response = client.post_json(create_endpoint, create_payload)
+        except APIRequestError as error:
+            response = (
+                _adopt_existing_create_response(error, name=name, columns=loaded_columns)
+                if policy == "adopt"
+                else None
+            )
+            if response is None:
+                raise
+        if verify:
+            resolved = _verify_created_table(client, target_workbook, name)
+            response = {
+                **response,
+                "verified": True,
+                "verified_gid": resolved.gid,
+                "verified_engine": resolved.engine,
+            }
+        context = {
+            "source_command": "db-table.create-from-range",
+            "read_endpoint": read_endpoint,
+            "create_endpoint": create_endpoint,
+            "source_document_id": source_workbook.document_id,
+            "source_worksheet_name": worksheet_name,
+            "source_range": cell_range,
+            **surface_summary,
+        }
+        render_output(
+            build_command_output(
+                endpoint=f"{read_endpoint} + {create_endpoint}",
+                target=_created_table_target(target_workbook, response),
+                result=response,
+                context=context,
+                metadata=get_endpoint_metadata("db-table.create-from-range") if state.verbose else None,
+            ),
+            state.output,
+        )
+    except Exception as error:  # pragma: no cover - CLI boundary
+        handle_cli_error(error)
+
+
 @app.command(
     "update",
     help="Planned: update PG/SheetTable-backed rows from JSON row data.",

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/src/maybeai_sheet/commands/excel_worksheet.py

@@ -454,6 +454,16 @@ def copy(
     gid: Optional[int] = typer.Option(None, "--gid", help="Worksheet gid."),
     worksheet_name: Optional[str] = typer.Option(None, "--worksheet-name", help="Worksheet name to copy."),
     new_name: str = typer.Option(..., "--new-name", help="Name for copied worksheet."),
+    target_doc_id: Optional[str] = typer.Option(
+        None,
+        "--target-doc-id",
+        help="Optional target document ID. Cross-document copy is currently unsupported.",
+    ),
+    target_url: Optional[str] = typer.Option(
+        None,
+        "--target-url",
+        help="Optional target workbook URL. Cross-document copy is currently unsupported.",
+    ),
     dry_run: bool = typer.Option(False, "--dry-run", help="Show the request without sending it."),
     output: Optional[str] = output_option(),
     verbose: Optional[bool] = verbose_option(),
@@ -467,6 +477,8 @@ def copy(
         gid=gid,
         worksheet_name=worksheet_name,
         new_name=new_name,
+        target_doc_id=target_doc_id,
+        target_url=target_url,
         dry_run=dry_run,
         output=output,
         verbose=verbose,

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/src/maybeai_sheet/commands/worksheet.py

@@ -6,8 +6,10 @@ from typing import Optional
 import typer
 
 from ..client import MaybeAIClient
+from ..errors import UsageError
 from ..formatters import handle_cli_error
 from ..options import output_option, timeout_option, verbose_option
+from ..resolver import parse_document_target
 from ._phase2 import (
     command_target,
     common_options,
@@ -163,6 +165,31 @@ def delete(
         handle_cli_error(error)
 
 
+def _reject_cross_document_worksheet_copy(
+    *,
+    source_document_id: str | None,
+    target_doc_id: str | None,
+    target_url: str | None,
+) -> None:
+    if not target_doc_id and not target_url:
+        return
+    resolved_target_doc_id = target_doc_id
+    if target_url:
+        parsed_doc_id, _gid = parse_document_target(target_url)
+        resolved_target_doc_id = resolved_target_doc_id or parsed_doc_id
+        if not resolved_target_doc_id:
+            raise UsageError("--target-url must include a MaybeAI document id.")
+    if source_document_id and resolved_target_doc_id == source_document_id:
+        return
+    raise UsageError(
+        "Cross-document excel-worksheet copy is unsupported: "
+        "/api/v1/excel/copy_worksheet only copies within one workbook "
+        "(uri, sheet, new_name). Use `mbs db-table create-from-range` to "
+        "materialize a PG/SheetTable raw surface from a source worksheet "
+        "range into the target workbook."
+    )
+
+
 @app.command("copy")
 def copy(
     ctx: typer.Context,
@@ -172,6 +199,16 @@ def copy(
     gid: Optional[int] = typer.Option(None, "--gid", help="Worksheet gid."),
     worksheet_name: Optional[str] = typer.Option(None, "--worksheet-name", help="Worksheet name to copy."),
     new_name: str = typer.Option(..., "--new-name", help="Name for copied worksheet."),
+    target_doc_id: Optional[str] = typer.Option(
+        None,
+        "--target-doc-id",
+        help="Optional target document ID. Cross-document copy is currently unsupported.",
+    ),
+    target_url: Optional[str] = typer.Option(
+        None,
+        "--target-url",
+        help="Optional target workbook URL. Cross-document copy is currently unsupported.",
+    ),
     dry_run: bool = typer.Option(False, "--dry-run", help="Show the request without sending it."),
     output: Optional[str] = output_option(),
     verbose: Optional[bool] = verbose_option(),
@@ -190,6 +227,11 @@ def copy(
             timeout=timeout,
         )
         target = command_target(state)
+        _reject_cross_document_worksheet_copy(
+            source_document_id=target.document_id,
+            target_doc_id=target_doc_id,
+            target_url=target_url,
+        )
         endpoint = "/api/v1/excel/copy_worksheet"
         payload = {
             "uri": target.uri,

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/src/maybeai_sheet/endpoints.py

@@ -70,6 +70,14 @@ COMMAND_ENDPOINTS: dict[str, EndpointMetadata] = {
     "db-table.insert": _meta("db-table.insert", "API", "POST", "/api/v1/excel/append_rows", verify_supported=True),
     "db-table.create": _meta("db-table.create", "API", "POST", "/api/v1/excel/db_table/create", verify_supported=True, notes="Creates a PG/SheetTable-backed table from JSON row data; --if-exists adopt verifies existing PG registry state."),
     "db-table.create-from-query": _meta("db-table.create-from-query", "API", "POST", "/api/v1/excel/calc-formula + /api/v1/excel/db_table/create", verify_supported=True, notes="CLI-composed SQL materialization: calculate =SQL(...) then create a PG/SheetTable table from the tabular result."),
+    "db-table.create-from-range": _meta(
+        "db-table.create-from-range",
+        "API",
+        "POST",
+        "/api/v1/excel/read_sheet + /api/v1/excel/db_table/create",
+        verify_supported=True,
+        notes="CLI-composed raw-surface import: read a source worksheet range, reshape header/data rows, then create a PG/SheetTable on the target workbook.",
+    ),
     "db-table.update": _meta("db-table.update", "PLAN", None, None, notes="Planned native db-table update route; CLI help documents keyed JSON row patches."),
     "db-table.delete": _meta("db-table.delete", "PLAN", None, None, destructive=True, confirmation_required=True, notes="Planned native db-table delete route."),
     "worksheet.list": _meta("worksheet.list", "NOW", "POST", "/api/v1/excel/list_worksheets"),
@@ -100,7 +108,14 @@ COMMAND_ENDPOINTS: dict[str, EndpointMetadata] = {
         dry_run_supported=True,
         confirmation_required=True,
     ),
-    "worksheet.copy": _meta("worksheet.copy", "API", "POST", "/api/v1/excel/copy_worksheet", dry_run_supported=True),
+    "worksheet.copy": _meta(
+        "worksheet.copy",
+        "API",
+        "POST",
+        "/api/v1/excel/copy_worksheet",
+        dry_run_supported=True,
+        notes="Same-document copy only. --target-doc-id/--target-url fail fast; use db-table create-from-range for cross-document raw surfaces.",
+    ),
     "worksheet.move": _meta("worksheet.move", "API", "POST", "/api/v1/excel/move_worksheet", dry_run_supported=True),
     "row.insert": _meta("row.insert", "API", "POST", "/api/v1/excel/insert_rows", dry_run_supported=True),
     "row.delete": _meta(

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/tests/test_endpoints.py

@@ -90,6 +90,7 @@ class EndpointRegistryTests(unittest.TestCase):
             "db-table.insert": ("API", "POST", "/api/v1/excel/append_rows"),
             "db-table.create": ("API", "POST", "/api/v1/excel/db_table/create"),
             "db-table.create-from-query": ("API", "POST", "/api/v1/excel/calc-formula + /api/v1/excel/db_table/create"),
+            "db-table.create-from-range": ("API", "POST", "/api/v1/excel/read_sheet + /api/v1/excel/db_table/create"),
             "db-table.update": ("PLAN", None, None),
             "db-table.delete": ("PLAN", None, None),
         }

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/tests/test_phase2_cli.py

@@ -125,6 +125,53 @@ class Phase2CLITests(unittest.TestCase):
         self.assertEqual(move_payload["sheet"], "Copy")
         self.assertEqual(move_payload["index"], 1)
 
+    def test_excel_worksheet_copy_rejects_cross_document_target(self) -> None:
+        with patch("maybeai_sheet.commands.worksheet.MaybeAIClient.post_json") as post_json:
+            result = self.runner.invoke(
+                app,
+                [
+                    "excel-worksheet",
+                    "copy",
+                    "--doc-id",
+                    "source123",
+                    "--worksheet-name",
+                    "1店",
+                    "--target-doc-id",
+                    "target123",
+                    "--new-name",
+                    "R_OrderLines_Store1",
+                ],
+                env=self.env,
+            )
+
+        self.assertNotEqual(result.exit_code, 0)
+        self.assertIn("Cross-document excel-worksheet copy is unsupported", result.output)
+        self.assertIn("db-table create-from-range", result.output)
+        post_json.assert_not_called()
+
+    def test_excel_worksheet_copy_allows_same_document_target_doc_id(self) -> None:
+        with patch("maybeai_sheet.commands.worksheet.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"success": True}
+            result = self.runner.invoke(
+                app,
+                [
+                    "excel-worksheet",
+                    "copy",
+                    "--doc-id",
+                    "abc123",
+                    "--worksheet-name",
+                    "Source",
+                    "--target-doc-id",
+                    "abc123",
+                    "--new-name",
+                    "Copy",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        self.assertEqual(post_json.call_args.args[0], "/api/v1/excel/copy_worksheet")
+
     def test_row_commands_use_verified_endpoints(self) -> None:
         with patch("maybeai_sheet.commands.row.MaybeAIClient.post_json") as post_json:
             post_json.return_value = {"success": True}

{maybeai_sheet_cli-0.13.2 → maybeai_sheet_cli-0.14.0}/tests/test_two_engine_cli.py

@@ -15,6 +15,7 @@ if str(SRC) not in sys.path:
     sys.path.insert(0, str(SRC))
 
 from maybeai_sheet.cli import app
+from maybeai_sheet.commands.db_table import _surface_from_values_matrix
 from maybeai_sheet.errors import APIRequestError, UsageError
 from maybeai_sheet.protocol import cli_group_for_model_label
 from maybeai_sheet.table_resolver import (
@@ -1135,6 +1136,187 @@ class TwoEngineCLITests(unittest.TestCase):
         self.assertEqual(trace["error"]["status_code"], 409)
         self.assertEqual(trace["error"]["body"], {"detail": "cannot persist formula in A1"})
 
+    def test_surface_from_values_matrix_header_names_and_blank_drop(self) -> None:
+        values = [
+            ["Merged Title", "", ""],
+            ["order_id", "amount", ""],
+            ["A1", 10, ""],
+            ["", "", ""],
+            ["A2", 20, "x"],
+        ]
+        columns, rows, summary = _surface_from_values_matrix(
+            values,
+            header_row=1,
+            use_header_names=True,
+        )
+        self.assertEqual([column["name"] for column in columns], ["order_id", "amount", "col_003"])
+        self.assertEqual(rows, [{"order_id": "A1", "amount": 10, "col_003": ""}, {"order_id": "A2", "amount": 20, "col_003": "x"}])
+        self.assertEqual(summary["rows_dropped_blank"], 1)
+        self.assertEqual(summary["data_start"], 2)
+
+        positional_columns, positional_rows, _summary = _surface_from_values_matrix(
+            values,
+            header_row=1,
+            use_header_names=False,
+        )
+        self.assertEqual(
+            [column["name"] for column in positional_columns],
+            ["raw_col_001", "raw_col_002", "raw_col_003"],
+        )
+        self.assertEqual(positional_rows[0]["raw_col_001"], "A1")
+
+    def test_db_table_create_from_range_reads_source_and_creates_on_target(self) -> None:
+        with patch("maybeai_sheet.commands.db_table.MaybeAIClient.post_json") as post_json:
+            post_json.side_effect = [
+                {
+                    "success": True,
+                    "values": [
+                        ["order_id", "amount", ""],
+                        ["A1", 10, ""],
+                        ["", "", ""],
+                        ["A2", 20, "note"],
+                    ],
+                },
+                {
+                    "success": True,
+                    "document_id": "target123",
+                    "worksheet_name": "R_OrderLines_Store1",
+                    "gid": 11,
+                    "engine": "pg",
+                    "created_rows": 2,
+                    "spreadsheet_url": "https://www.maybe.ai/docs/spreadsheets/d/target123?gid=11",
+                },
+                {
+                    "success": True,
+                    "worksheets": [
+                        {
+                            "gid": 11,
+                            "worksheet_name": "R_OrderLines_Store1",
+                            "data_engine": "pg",
+                        }
+                    ],
+                },
+            ]
+            result = self.runner.invoke(
+                app,
+                [
+                    "db-table",
+                    "create-from-range",
+                    "--doc-id",
+                    "target123",
+                    "--name",
+                    "R_OrderLines_Store1",
+                    "--source-doc-id",
+                    "source123",
+                    "--worksheet-name",
+                    "1店",
+                    "--range",
+                    "A2:C5",
+                    "--header-row",
+                    "0",
+                    "--use-header-names",
+                    "--if-exists",
+                    "adopt",
+                    "--verify",
+                    "--output",
+                    "json",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        self.assertEqual(post_json.call_args_list[0].args[0], "/api/v1/excel/read_sheet")
+        read_payload = post_json.call_args_list[0].args[1]
+        self.assertEqual(read_payload["uri"], "https://www.maybe.ai/docs/spreadsheets/d/source123")
+        self.assertEqual(read_payload["worksheet_name"], "1店")
+        self.assertEqual(read_payload["range_address"], "A2:C5")
+        self.assertEqual(post_json.call_args_list[1].args[0], "/api/v1/excel/db_table/create")
+        create_payload = post_json.call_args_list[1].args[1]
+        self.assertEqual(create_payload["document_id"], "target123")
+        self.assertEqual(create_payload["uri"], "https://www.maybe.ai/docs/spreadsheets/d/target123")
+        self.assertEqual(create_payload["name"], "R_OrderLines_Store1")
+        self.assertEqual(create_payload["if_exists"], "adopt")
+        self.assertEqual(
+            create_payload["columns"],
+            [
+                {"name": "order_id", "logical_type": "text", "index": 0},
+                {"name": "amount", "logical_type": "text", "index": 1},
+                {"name": "col_003", "logical_type": "text", "index": 2},
+            ],
+        )
+        self.assertEqual(
+            create_payload["rows"],
+            [
+                {"order_id": "A1", "amount": 10, "col_003": ""},
+                {"order_id": "A2", "amount": 20, "col_003": "note"},
+            ],
+        )
+        data = json.loads(result.output)
+        self.assertEqual(data["endpoint"], "/api/v1/excel/read_sheet + /api/v1/excel/db_table/create")
+        self.assertEqual(data["target"]["document_id"], "target123")
+        self.assertEqual(data["context"]["source_document_id"], "source123")
+        self.assertEqual(data["context"]["source_worksheet_name"], "1店")
+        self.assertEqual(data["context"]["source_range"], "A2:C5")
+        self.assertEqual(data["context"]["header_row"], 0)
+        self.assertTrue(data["context"]["use_header_names"])
+        self.assertEqual(data["context"]["row_count"], 2)
+        self.assertEqual(data["context"]["rows_dropped_blank"], 1)
+        self.assertTrue(data["result"]["verified"])
+
+    def test_db_table_create_from_range_uses_positional_columns_by_default(self) -> None:
+        with patch("maybeai_sheet.commands.db_table.MaybeAIClient.post_json") as post_json:
+            post_json.side_effect = [
+                {"success": True, "values": [["h1", "h2"], ["v1", "v2"]]},
+                {
+                    "success": True,
+                    "document_id": "target123",
+                    "worksheet_name": "R_Positional",
+                    "gid": 12,
+                    "engine": "pg",
+                    "created_rows": 1,
+                },
+            ]
+            result = self.runner.invoke(
+                app,
+                [
+                    "db-table",
+                    "create-from-range",
+                    "--doc-id",
+                    "target123",
+                    "--name",
+                    "R_Positional",
+                    "--source-doc-id",
+                    "source123",
+                    "--worksheet-name",
+                    "Sheet1",
+                    "--range",
+                    "A1:B2",
+                    "--output",
+                    "json",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        create_payload = post_json.call_args_list[1].args[1]
+        self.assertEqual(
+            [column["name"] for column in create_payload["columns"]],
+            ["raw_col_001", "raw_col_002"],
+        )
+        self.assertEqual(create_payload["rows"], [{"raw_col_001": "v1", "raw_col_002": "v2"}])
+        data = json.loads(result.output)
+        self.assertFalse(data["context"]["use_header_names"])
+
+    def test_db_table_create_from_range_help_lists_options(self) -> None:
+        result = self.runner.invoke(app, ["db-table", "create-from-range", "--help"], env=self.env)
+        self.assertEqual(result.exit_code, 0, result.output)
+        self.assertIn("--source-doc-id", result.output)
+        self.assertIn("--header-row", result.output)
+        self.assertIn("--use-header-names", result.output)
+        self.assertIn("--range", result.output)
+        self.assertIn("--if-exists", result.output)
+        self.assertIn("--verify", result.output)
+
     def test_db_table_create_adopts_existing_pg_table_with_verify(self) -> None:
         with tempfile.NamedTemporaryFile(mode="w+", suffix=".json") as rows_file, tempfile.NamedTemporaryFile(mode="w+", suffix=".json") as columns_file:
             json.dump([], rows_file)