Files
make-cad/src/simplecadapi/editor/cli.py
T
NiJingzhe 3d4e789da6 fix(editor): take in edits made to the notebook file; sca cell / sca new
The editor held the open notebook in memory and rewrote the file on each edit, so an
agent's saved change was overwritten and never noticed. The file is now watched and
applied cell by cell (agent's version wins a same-cell conflict), the workspace list
follows new files, and sca cell/new edit through the running editor.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-14 15:30:40 +08:00

327 lines
14 KiB
Python

"""The ``sca edit`` command (see :mod:`simplecadapi.cli`).
::
sca edit [WORKSPACE] # open the editor on a directory of notebooks
sca edit path/to/model.py # ... starting at one notebook
sca edit --port 7180 --no-browser
sca snapshot [WORKSPACE] # what the person has selected / is looking at
sca cell ls|get|put|insert|rm|run # edit the cells of the notebook the editor has open
sca new NAME [--kind part|assembly] # a new notebook; the editor lists it at once
"""
from __future__ import annotations
import argparse
from pathlib import Path
from typing import Any
DEFAULT_PORT = 7180
def configure(subparsers: argparse._SubParsersAction) -> None:
parser = subparsers.add_parser(
"edit",
help="open the web editor on a workspace of SimpleCAD notebooks",
description="Serve the code-first CAD editor for WORKSPACE (default: the "
"current directory): a directory of notebooks with [tool.simplecadapi] "
"headers, or one such notebook. Needs the 'editor' extra.",
)
parser.add_argument("workspace", type=Path, nargs="?", default=Path.cwd())
parser.add_argument("--host", default="127.0.0.1")
parser.add_argument("--port", type=int, default=DEFAULT_PORT)
parser.add_argument("--no-browser", action="store_true", help="do not open a browser tab")
parser.set_defaults(handler=_execute, printer=lambda report: None)
snapshot = subparsers.add_parser(
"snapshot",
help="print what the editor user has selected and is looking at",
description="Print the editor's snapshot for WORKSPACE (default: the current "
"directory) as JSON: the selection (the ql code is in the notebook's selection "
"cell, saved in the file), the cells' state and errors, the parameter values, and "
"the path of the viewport image (a PNG an agent can look at). The editor keeps "
"it in WORKSPACE/.sca-editor/ while it runs.",
)
snapshot.add_argument("workspace", type=Path, nargs="?", default=Path.cwd())
snapshot.set_defaults(handler=_snapshot, printer=_print_snapshot)
cell = subparsers.add_parser(
"cell",
help="read and edit the cells of a notebook through the running editor",
description="Edit a notebook's cells through the editor that has it open: the page "
"shows the change live (no reload) and the editor, the one writer of the file, saves "
"it, so nothing is overwritten. Cells are named by number (see `sca cell ls`), by key "
"or by id. When the editor is not running, or has another notebook open, `ls` and "
"`get` read the file and the write commands refuse: edit the file directly then, "
"nothing else holds it.",
)
cell_sub = cell.add_subparsers(dest="cell_command", required=True)
def common(parser: argparse.ArgumentParser) -> None:
parser.add_argument("--notebook", "-n", type=Path, default=None, help="the notebook (default: the one the editor has open)")
parser.add_argument("--workspace", "-w", type=Path, default=None, help="the workspace the editor serves (default: found from the current directory)")
ls = cell_sub.add_parser("ls", help="list the cells with their state")
common(ls)
ls.add_argument("--code", action="store_true", help="include each cell's code")
ls.set_defaults(handler=_cell_ls, printer=_print_json)
get = cell_sub.add_parser("get", help="print one cell: its code, state, errors and output")
common(get)
get.add_argument("cell")
get.set_defaults(handler=_cell_get, printer=_print_json)
put = cell_sub.add_parser("put", help="replace a cell's code (the code comes from --file or stdin) and run it")
common(put)
put.add_argument("cell")
put.add_argument("--file", "-f", type=Path, default=None, help="read the code from this file (default: stdin)")
put.add_argument("--no-run", action="store_true", help="save the code without running the cell")
put.set_defaults(handler=_cell_put, printer=_print_json)
insert = cell_sub.add_parser("insert", help="add a cell (the code comes from --file or stdin)")
common(insert)
insert.add_argument("--after", default="end", help="a cell, or `start` / `end` (default)")
insert.add_argument("--name", default=None, help="the cell's function name")
insert.add_argument("--file", "-f", type=Path, default=None)
insert.add_argument("--no-run", action="store_true")
insert.set_defaults(handler=_cell_insert, printer=_print_json)
rm = cell_sub.add_parser("rm", help="delete a cell")
common(rm)
rm.add_argument("cell")
rm.set_defaults(handler=_cell_rm, printer=_print_json)
run = cell_sub.add_parser("run", help="run cells (default: all) and what they feed")
common(run)
run.add_argument("cells", nargs="*")
run.set_defaults(handler=_cell_run, printer=_print_json)
new = subparsers.add_parser(
"new",
help="create a notebook in the workspace (the running editor lists it at once)",
description="Write a new notebook from the template into WORKSPACE (default: the "
"current directory). A running editor on that workspace lists it without a reload.",
)
new.add_argument("name")
new.add_argument("--kind", choices=("part", "assembly"), default="part")
new.add_argument("--workspace", "-w", type=Path, default=None)
new.set_defaults(handler=_new_notebook, printer=_print_json)
def _execute(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
try:
from .server import serve_workspace
except ModuleNotFoundError as error:
raise ValueError(
f"the editor needs the 'editor' extra ({error.name} is missing): "
'pip install "simplecadapi[editor]"'
) from error
target = args.workspace.expanduser().resolve()
notebook = None
if target.is_file():
notebook, target = target, target.parent
elif not target.is_dir():
raise ValueError(f"{args.workspace}: no such file or directory")
code = serve_workspace(
target,
host=args.host,
port=args.port,
open_browser=not args.no_browser,
notebook=notebook,
)
return {}, code
def _snapshot(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
import json
root = args.workspace.expanduser().resolve()
if root.is_file():
root = root.parent
path = root / ".sca-editor" / "snapshot.json"
if not path.is_file():
raise ValueError(f"{root}: no editor snapshot; is `sca edit` running on this workspace?")
return json.loads(path.read_text(encoding="utf-8")), 0
def _print_snapshot(report: dict[str, Any]) -> None:
import json
print(json.dumps(report, indent=2, ensure_ascii=False))
# -- sca cell / sca new ---------------------------------------------------------
def _print_json(report: dict[str, Any]) -> None:
import json
print(json.dumps(report, indent=2, ensure_ascii=False))
def _find_editor(start: Path) -> tuple[Path, str] | None:
"""The running editor whose workspace holds *start*: ``(workspace, base url)``."""
import json
import urllib.request
here = start.expanduser().resolve()
for directory in (here, *here.parents):
record = directory / ".sca-editor" / "server.json"
if not record.is_file():
continue
try:
url = json.loads(record.read_text(encoding="utf-8"))["url"]
with urllib.request.urlopen(f"{url}/api/health", timeout=1.5):
pass
except (OSError, ValueError, KeyError):
continue # a stale record: the editor is gone
return directory, str(url)
return None
def _call(url: str, path: str, body: dict | None = None) -> dict[str, Any]:
import json
import urllib.error
import urllib.request
data = None if body is None else json.dumps(body).encode("utf-8")
request = urllib.request.Request(
url + path, data=data, headers={"Content-Type": "application/json"}, method="GET" if body is None else "POST"
)
try:
with urllib.request.urlopen(request, timeout=300) as response:
return json.loads(response.read())
except urllib.error.HTTPError as error:
try:
return json.loads(error.read())
except ValueError:
return {"error": f"editor answered {error.code}"}
def _session(args: argparse.Namespace, *, write: bool) -> tuple[str | None, Path | None, str]:
"""``(editor url or None, notebook path or None, relative notebook name)`` for a cell command."""
start = args.workspace or (args.notebook.parent if args.notebook else Path.cwd())
found = _find_editor(start)
notebook = args.notebook.expanduser().resolve() if args.notebook else None
if found is None:
if write:
raise ValueError(
"no editor is running on this workspace (start `sca edit`), or edit the notebook file "
"directly: nothing else holds it"
)
if notebook is None:
raise ValueError("no editor is running here; name the notebook with --notebook")
return None, notebook, notebook.name
workspace, url = found
open_path = _call(url, "/api/cells").get("notebook")
if notebook is None:
if open_path is None:
raise ValueError("the editor has no notebook open")
return url, workspace / open_path, open_path
relative = notebook.relative_to(workspace).as_posix() if notebook.is_relative_to(workspace) else notebook.name
if relative == open_path:
return url, notebook, relative
if write:
raise ValueError(
f"the editor has {open_path} open, not {relative}: edit {relative} directly "
"(the editor does not hold it), or open it in the editor first"
)
return None, notebook, relative
def _cells_from_file(notebook: Path) -> list[dict[str, Any]]:
from ..runtime._marimo import parse_notebook
parsed = parse_notebook(notebook.read_text(encoding="utf-8"))
cells = []
for cell in (parsed.cells if parsed is not None else []):
if getattr(cell, "name", None) == "setup":
continue
cells.append({"index": len(cells) + 1, "name": getattr(cell, "name", None), "code": cell.code, "source": "file"})
return cells
def _slim(report: dict[str, Any], *, code: bool) -> dict[str, Any]:
if "cells" not in report:
return report
keep = ("index", "key", "name", "title", "status", "errors", "output", "ref", "readonly")
return {
**report,
"cells": [
{**{k: c[k] for k in keep if k in c and c[k] not in (None, [], False)}, **({"code": c["code"]} if code else {})}
for c in report["cells"]
],
}
def _cell_ls(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
url, notebook, name = _session(args, write=False)
if url is None:
assert notebook is not None
return {"notebook": name, "source": "file", "cells": _cells_from_file(notebook)}, 0
return _slim(_call(url, "/api/cells"), code=args.code), 0
def _cell_get(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
url, notebook, name = _session(args, write=False)
if url is None:
assert notebook is not None
cells = _cells_from_file(notebook)
if not args.cell.isdigit() or not 1 <= int(args.cell) <= len(cells):
raise ValueError("without the editor, name a cell by its number (see `sca cell ls`)")
return {"notebook": name, "source": "file", **cells[int(args.cell) - 1]}, 0
report = _call(url, "/api/cells")
for cell in report.get("cells", []):
if args.cell in (str(cell["index"]), cell.get("key"), cell["id"]):
return {"notebook": report.get("notebook"), **cell}, 0
raise ValueError(f"no cell {args.cell!r}; run `sca cell ls`")
def _read_code(args: argparse.Namespace) -> str:
import sys
if args.file is not None:
return args.file.read_text(encoding="utf-8")
if sys.stdin.isatty():
raise ValueError("give the code with --file, or on stdin")
return sys.stdin.read()
def _write_op(args: argparse.Namespace, op: str, body: dict[str, Any]) -> tuple[dict[str, Any], int]:
url, _notebook, _name = _session(args, write=True)
assert url is not None
report = _call(url, f"/api/cells/{op}", body)
if "error" in report:
return _slim(report, code=False), 1
touched = set(report.get("touched", []))
report = _slim(report, code=False)
# What the change did: the touched cells with their state; the rest as a count.
report["cells"] = [c for c in report["cells"] if c.get("index") in touched] or report["cells"]
return report, 0
def _cell_put(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
return _write_op(args, "edit", {"cell": args.cell, "code": _read_code(args), "run": not args.no_run})
def _cell_insert(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
return _write_op(args, "insert", {"after": args.after, "name": args.name, "code": _read_code(args), "run": not args.no_run})
def _cell_rm(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
return _write_op(args, "delete", {"cell": args.cell})
def _cell_run(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
return _write_op(args, "run", {"cells": args.cells})
def _new_notebook(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
from .templates import create_notebook
start = (args.workspace or Path.cwd()).expanduser().resolve()
found = _find_editor(start)
root = found[0] if found is not None else start
# Only the file is written: the running editor lists it on its own and the
# person's current notebook stays open.
path = create_notebook(root, args.name, args.kind)
return {"ok": True, "path": str(path), "editor_listed": found is not None}, 0
__all__ = ["configure"]