rdstudio 0.2.0__py3-none-any.whl

rdstudio/cli.py

@@ -0,0 +1,369 @@
+"""Command-line interface: ``rdstudio <command>``."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__
+from . import config as config_mod
+from .okf import Bundle
+
+
+def _bundle(cfg: config_mod.Config) -> Bundle:
+    return Bundle.load(cfg.knowledge_dir)
+
+
+def cmd_check(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    bundle = _bundle(cfg)
+    issues = bundle.lint()
+    errors = [i for i in issues if i.level == "error"]
+    for issue in issues:
+        if issue.level == "error" or args.warnings:
+            print(f"{issue.level:7} {issue.path}: {issue.message}")
+    warnings = len(issues) - len(errors)
+    print(f"{len(bundle.concepts)} concepts, {len(errors)} errors, {warnings} warnings")
+    return 1 if errors else 0
+
+
+def cmd_index(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    bundle = _bundle(cfg)
+    changed = bundle.write_indexes()
+    for path in changed:
+        print(f"wrote {path}")
+    if not changed:
+        print("indexes up to date")
+    return 0
+
+
+def cmd_search(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from .search import Index
+
+    hits = Index(_bundle(cfg)).search(
+        " ".join(args.query), limit=args.limit, type=args.type, tags=args.tag, under=args.under
+    )
+    if args.json:
+        print(json.dumps([h.as_dict() for h in hits], indent=2))
+        return 0
+    for h in hits:
+        print(f"{h.score:6.2f}  {h.concept.id}  [{h.concept.type}]  {h.concept.title}")
+        if h.snippet:
+            print(f"        {h.snippet}")
+    return 0
+
+
+def cmd_verify(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from .store import verify
+
+    actor = args.by or cfg.human
+    if not actor.startswith("human:"):
+        print("set [actors] human = \"human:<id>\" in rdstudio.toml or ~/.config/rdstudio/config.toml, "
+              "or pass --by human:<id>", file=sys.stderr)
+        return 2
+    for ref in args.concepts:
+        result = verify(cfg.knowledge_dir, ref, actor=actor)
+        print(f"verified {result.path} by {actor}")
+    return 0
+
+
+def cmd_build(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from .build import build
+
+    out = build(cfg)
+    print(f"built {out}")
+    return 0
+
+
+def cmd_export(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    import shutil
+    import tempfile
+
+    from .build import build
+
+    target = Path(args.target).resolve()
+    if target.exists() and any(target.iterdir()) and not args.force:
+        print(f"{target} is not empty; pass --force to replace it", file=sys.stderr)
+        return 1
+    with tempfile.TemporaryDirectory() as tmp:
+        site = build(cfg, write_indexes=False, export=True, site=Path(tmp) / "site")
+        (site / ".nojekyll").write_text("")
+        if target.exists():
+            shutil.rmtree(target)
+        shutil.copytree(site, target)
+    print(f"exported a static snapshot to {target} (project knowledge only)")
+    return 0
+
+
+def cmd_serve(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from .serve import serve
+
+    serve(cfg, host=args.host, port=args.port, watch=not args.no_watch, allow_hosts=tuple(args.allow_host))
+    return 0
+
+
+def cmd_init(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from .scaffold import init
+
+    target = Path(args.path).resolve()
+    for line in init(target, title=args.title, human=args.human, force=args.force):
+        print(line)
+    return 0
+
+
+def cmd_procedure(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from . import procedures
+
+    bundle = _bundle(cfg)
+    if args.action == "list":
+        for c in bundle.concepts.values():
+            if procedures.is_procedure(c):
+                pending = sum(p.get("state") == "pending" for p in c.meta.get("proposals") or [])
+                g = procedures.graph_of(c)
+                print(f"{c.id}  {len(g.nodes)} steps, {len(g.edges)} transitions"
+                      + (f", {pending} pending proposal(s)" if pending else ""))
+        return 0
+    cid = bundle.resolve_id(args.procedure or "") or bundle.resolve_id("procedures/" + (args.procedure or ""))
+    if cid is None:
+        print(f"no procedure {args.procedure!r}", file=sys.stderr)
+        return 2
+    if args.action == "show":
+        c = bundle.concepts[cid]
+        for p in c.meta.get("proposals") or []:
+            print(f"#{p.get('id')} [{p.get('state')}] by {p.get('by')}: {p.get('rationale')}")
+            for e in p.get("edits", []):
+                print("    " + ", ".join(f"{k}={v}" for k, v in e.items()))
+        return 0
+    actor = cfg.human or "human:unknown"
+    try:
+        result = procedures.resolve(cfg.knowledge_dir, cid, args.proposal, accept=args.action == "apply", actor=actor)
+    except procedures.ProcedureError as exc:
+        print(exc, file=sys.stderr)
+        return 1
+    print(f"proposal {result['proposal']} on {cid}: {result['state']}")
+    return 0
+
+
+def cmd_refs(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from . import references
+
+    if not references.enabled(cfg):
+        print('references are off: add [references] backend = "papis" to rdstudio.toml', file=sys.stderr)
+        return 2
+    try:
+        if args.action == "sync":
+            created = references.sync_stubs(cfg)
+            for cid in created:
+                print(f"created {cid}")
+            print(f"{len(created)} new reference stubs")
+        elif args.action == "search":
+            for hit in references.search(cfg, " ".join(args.terms)):
+                print(f"{hit['ref']:32} {hit['year']:5} {hit['title']}")
+        elif args.action == "text":
+            print(references.text(cfg, args.terms[0], pages=args.pages))
+    except references.ReferenceError as exc:
+        print(exc, file=sys.stderr)
+        return 1
+    return 0
+
+
+def cmd_global(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from . import scopes
+
+    if args.action == "init":
+        for line in scopes.init_global(Path(args.path), human=args.human):
+            print(line)
+        return 0
+    g = scopes.global_config(cfg)
+    if g is None:
+        print("no global knowledge base; run `rdstudio global init [~/knowledge]`")
+        return 1
+    print(f"global knowledge base: {g.root} ({len(_bundle(g).concepts)} concepts)")
+    return 0
+
+
+def cmd_promote(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from . import scopes
+
+    try:
+        result = scopes.promote(cfg, args.concept, as_id=args.as_id, keep=args.keep, force=args.force)
+    except scopes.ScopeError as exc:
+        print(exc, file=sys.stderr)
+        return 1
+    verb = "moved" if result["moved"] else "copied"
+    print(f"{verb} {result['from']} to the global knowledge base as {result['to']}")
+    if result["broken_links_in_global"]:
+        print("links that do not resolve in the global base: " + ", ".join(result["broken_links_in_global"]))
+    return 0
+
+
+def cmd_skills(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from . import scopes
+
+    if args.action == "list":
+        for scope, skills in scopes.skill_dirs(cfg).items():
+            print(f"{scope}: {', '.join(skills) or '(none)'}")
+        return 0
+    try:
+        print(scopes.move_skill(cfg, args.name, args.action.split("-")[-1]))
+    except scopes.ScopeError as exc:
+        print(exc, file=sys.stderr)
+        return 1
+    return 0
+
+
+def cmd_brief(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from .brief import brief
+
+    print(brief(cfg))
+    return 0
+
+
+def cmd_learner(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from . import learner
+
+    if args.action == "where":
+        state = "on" if learner.enabled(cfg) else "off (set [learner] enabled = true in " + str(config_mod.user_config_path()) + ")"
+        print(f"learner record: {state}")
+        print(f"project id:     {learner.project_id(cfg.root)}")
+        print(f"folder:         {learner.record_dir(cfg)}")
+        return 0
+    for e in learner.events(cfg)[-args.limit:]:
+        rest = {k: v for k, v in e.items() if k not in ("at", "event", "concept")}
+        print(f"{e.get('at', '')}  {e.get('event', ''):10} {e.get('concept', '') or ''}  {json.dumps(rest) if rest else ''}")
+    return 0
+
+
+def cmd_path(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    bundle = _bundle(cfg)
+    if args.concept:
+        cid = bundle.resolve_id(args.concept)
+        if not cid:
+            print(f"no such concept: {args.concept}", file=sys.stderr)
+            return 1
+        ids = bundle.prerequisites(cid) + [cid]
+    else:
+        ids = sorted(bundle.concepts, key=lambda c: bundle.prerequisite_order()[c]["order"])
+    order = bundle.prerequisite_order()
+    for i, cid in enumerate(ids, 1):
+        print(f"{i:3}. [{order[cid]['depth']}] {cid}  {bundle.concepts[cid].title}")
+    return 0
+
+
+def cmd_mcp(args: argparse.Namespace, cfg: config_mod.Config) -> int:
+    from .mcp_server import run
+
+    if args.agent:
+        cfg.agent = args.agent
+    run(cfg)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="rdstudio", description=__doc__)
+    p.add_argument("--version", action="version", version=f"rdstudio {__version__}")
+    p.add_argument("-C", "--directory", help="run as if started in this directory")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    s = sub.add_parser("init", help="scaffold rdstudio into a repository")
+    s.add_argument("path", nargs="?", default=".")
+    s.add_argument("--title", help="project title")
+    s.add_argument("--human", help="your actor id, e.g. human:lachlan")
+    s.add_argument("--force", action="store_true", help="overwrite rdstudio-managed files")
+    s.set_defaults(func=cmd_init)
+
+    s = sub.add_parser("check", help="check OKF conformance of the knowledge bundle")
+    s.add_argument("-w", "--warnings", action="store_true", help="also print warnings")
+    s.set_defaults(func=cmd_check)
+
+    s = sub.add_parser("index", help="regenerate index.md files")
+    s.set_defaults(func=cmd_index)
+
+    s = sub.add_parser("search", help="search the knowledge bundle")
+    s.add_argument("query", nargs="+")
+    s.add_argument("-n", "--limit", type=int, default=8)
+    s.add_argument("--type")
+    s.add_argument("--tag", action="append")
+    s.add_argument("--under", help="restrict to a directory")
+    s.add_argument("--json", action="store_true")
+    s.set_defaults(func=cmd_search)
+
+    s = sub.add_parser("verify", help="record a human verification of concepts")
+    s.add_argument("concepts", nargs="+", help="concept ids or paths")
+    s.add_argument("--by", help="actor, default from config")
+    s.set_defaults(func=cmd_verify)
+
+    s = sub.add_parser("build", help="build the dashboard site")
+    s.set_defaults(func=cmd_build)
+
+    s = sub.add_parser("export", help="write a static snapshot of the dashboard (e.g. for GitHub Pages)")
+    s.add_argument("target")
+    s.add_argument("--force", action="store_true", help="replace a non-empty target directory")
+    s.set_defaults(func=cmd_export)
+
+    s = sub.add_parser("serve", help="serve the dashboard, rebuilding on change")
+    s.add_argument("--host", default="127.0.0.1")
+    s.add_argument("--port", type=int, default=8000)
+    s.add_argument("--no-watch", action="store_true")
+    s.add_argument("--allow-host", action="append", default=[], metavar="NAME",
+                   help="a host name a reverse proxy passes through (Tailscale's *.ts.net names are allowed already)")
+    s.set_defaults(func=cmd_serve)
+
+    s = sub.add_parser("procedure", help="list procedures; show, apply or reject proposed edits")
+    s.add_argument("action", choices=["list", "show", "apply", "reject"])
+    s.add_argument("procedure", nargs="?")
+    s.add_argument("proposal", nargs="?", type=int)
+    s.set_defaults(func=cmd_procedure)
+
+    s = sub.add_parser("refs", help="papis references: sync stubs, search, read PDF text")
+    s.add_argument("action", choices=["sync", "search", "text"])
+    s.add_argument("terms", nargs="*")
+    s.add_argument("--pages")
+    s.set_defaults(func=cmd_refs)
+
+    s = sub.add_parser("global", help="set up or show the global knowledge base")
+    s.add_argument("action", choices=["init", "status"])
+    s.add_argument("path", nargs="?", default="~/knowledge")
+    s.add_argument("--human", help="your actor id, e.g. human:lachlan")
+    s.set_defaults(func=cmd_global)
+
+    s = sub.add_parser("promote", help="move a project concept into the global knowledge base")
+    s.add_argument("concept")
+    s.add_argument("--as", dest="as_id", help="id in the global base (default: same path)")
+    s.add_argument("--keep", action="store_true", help="copy instead of move")
+    s.add_argument("--force", action="store_true", help="move even if project concepts link to it")
+    s.set_defaults(func=cmd_promote)
+
+    s = sub.add_parser("skills", help="list skills by scope, or move one between project and user scope")
+    s.add_argument("action", choices=["list", "to-user", "to-project"])
+    s.add_argument("name", nargs="?")
+    s.set_defaults(func=cmd_skills)
+
+    s = sub.add_parser("brief", help="print a short orientation for an agent session")
+    s.set_defaults(func=cmd_brief)
+
+    s = sub.add_parser("learner", help="where your private learner record is, or its recent events")
+    s.add_argument("action", choices=["where", "log"], nargs="?", default="where")
+    s.add_argument("-n", "--limit", type=int, default=30)
+    s.set_defaults(func=cmd_learner)
+
+    s = sub.add_parser("path", help="a concept's prerequisites in reading order, or the whole bundle's reading order")
+    s.add_argument("concept", nargs="?", help="concept id; omit for the whole bundle")
+    s.set_defaults(func=cmd_path)
+
+    s = sub.add_parser("mcp", help="run the MCP server on stdio")
+    s.add_argument("--agent", help="actor id stamped on the agent's writes (default: [actors] agent)")
+    s.set_defaults(func=cmd_mcp)
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    start = Path(args.directory).resolve() if args.directory else None
+    cfg = config_mod.load(start)
+    return args.func(args, cfg) or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

rdstudio/config.py

@@ -0,0 +1,115 @@
+"""Project (``rdstudio.toml``) and user (``~/.config/rdstudio/config.toml``) configuration."""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+PROJECT_FILE = "rdstudio.toml"
+
+DEFAULT_CATEGORIES: dict[str, list[str]] = {
+    "knowledge": ["{knowledge}/**"],
+    "reports": ["{reports}/**"],
+    "agent": [".claude/**", ".mcp.json", "CLAUDE.md", "AGENTS.md", ".opencode/**", "opencode.json",
+              "opencode.jsonc", "rdstudio.toml"],
+    "code": [
+        "**/*.py", "**/*.pyi", "**/*.ts", "**/*.js", "**/*.svelte", "**/*.rs", "**/*.c",
+        "**/*.cpp", "**/*.h", "**/*.jl", "**/*.go", "**/*.java", "**/*.sh", "**/*.css",
+        "**/*.html", "**/*.toml", "**/*.lock", "**/pyproject.toml", "**/package.json",
+    ],
+}
+
+
+def user_config_path() -> Path:
+    base = os.environ.get("XDG_CONFIG_HOME") or str(Path.home() / ".config")
+    return Path(base) / "rdstudio" / "config.toml"
+
+
+def _read_toml(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    with path.open("rb") as fh:
+        return tomllib.load(fh)
+
+
+def find_project_root(start: Path | None = None) -> Path | None:
+    """Walk up from ``start`` to the nearest directory holding ``rdstudio.toml``."""
+    here = (start or Path.cwd()).resolve()
+    for candidate in (here, *here.parents):
+        if (candidate / PROJECT_FILE).is_file():
+            return candidate
+    return None
+
+
+@dataclass
+class Config:
+    root: Path
+    title: str = "rdstudio"
+    knowledge: str = "knowledge"
+    reports: str = "reports"
+    output: str = ".rdstudio"
+    human: str = ""  # e.g. "human:lachlan"
+    agent: str = "claude-code/unknown"
+    categories: dict[str, list[str]] = field(default_factory=dict)
+    global_bundle: Path | None = None
+    use_global: bool = True
+    is_project: bool = True
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def knowledge_dir(self) -> Path:
+        return self.root / self.knowledge
+
+    @property
+    def reports_dir(self) -> Path:
+        return self.root / self.reports
+
+    @property
+    def output_dir(self) -> Path:
+        return self.root / self.output
+
+    @property
+    def site_dir(self) -> Path:
+        return self.output_dir / "site"
+
+    def category_globs(self) -> dict[str, list[str]]:
+        cats = self.categories or DEFAULT_CATEGORIES
+        fmt = {"knowledge": self.knowledge, "reports": self.reports}
+        return {name: [g.format(**fmt) for g in globs] for name, globs in cats.items()}
+
+
+def load(start: Path | None = None) -> Config:
+    """Load configuration for the project containing ``start`` (default: cwd).
+
+    Outside a project, the root is ``start`` itself and defaults apply.
+    """
+    user = _read_toml(user_config_path())
+    root = find_project_root(start)
+    is_project = root is not None
+    root = root or (start or Path.cwd()).resolve()
+    project = _read_toml(root / PROJECT_FILE)
+
+    proj = project.get("project", {})
+    paths = project.get("paths", {})
+    actors = {**user.get("actors", {}), **project.get("actors", {})}
+    glob = user.get("global", {})
+
+    global_path = glob.get("path")
+    cfg = Config(
+        root=root,
+        title=proj.get("title") or root.name,
+        knowledge=paths.get("knowledge", "knowledge"),
+        reports=paths.get("reports", "reports"),
+        output=paths.get("output", ".rdstudio"),
+        human=actors.get("human", ""),
+        agent=actors.get("agent", "claude-code/unknown"),
+        categories=project.get("changes", {}).get("categories", {}),
+        global_bundle=Path(global_path).expanduser() if global_path else None,
+        use_global=project.get("global", {}).get("enabled", True),
+        is_project=is_project,
+        raw=project,
+    )
+    return cfg

rdstudio/gitlog.py

@@ -0,0 +1,92 @@
+"""Commit-by-commit change lists, with each file sorted into a category."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+_STATUS = {"A": "added", "M": "modified", "D": "deleted", "R": "renamed", "C": "copied", "T": "modified"}
+
+
+@lru_cache(maxsize=256)
+def _glob_regex(pattern: str) -> re.Pattern[str]:
+    out, i = "", 0
+    while i < len(pattern):
+        if pattern.startswith("**/", i):
+            out, i = out + "(?:.*/)?", i + 3
+        elif pattern.startswith("**", i):
+            out, i = out + ".*", i + 2
+        elif pattern[i] == "*":
+            out, i = out + "[^/]*", i + 1
+        elif pattern[i] == "?":
+            out, i = out + "[^/]", i + 1
+        else:
+            out, i = out + re.escape(pattern[i]), i + 1
+    return re.compile(out + r"\Z")
+
+
+def categorise(path: str, categories: dict[str, list[str]]) -> str:
+    for name, globs in categories.items():
+        if any(_glob_regex(g).match(path) for g in globs):
+            return name
+    return "other"
+
+
+def _git(root: Path, *args: str) -> str | None:
+    try:
+        proc = subprocess.run(
+            ["git", "-C", str(root), *args], capture_output=True, text=True, timeout=20, check=False
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return proc.stdout if proc.returncode == 0 else None
+
+
+def history(root: Path, categories: dict[str, list[str]], limit: int = 200,
+            exclude: tuple[str, ...] = (".rdstudio/",)) -> dict[str, Any]:
+    """Recent commits (newest first), plus uncommitted changes as a pseudo-commit.
+
+    Paths under ``exclude`` prefixes (build output) are left out."""
+    if _git(root, "rev-parse", "--is-inside-work-tree") is None:
+        return {"available": False, "commits": []}
+    commits: list[dict[str, Any]] = []
+
+    status = _git(root, "status", "--porcelain", "-uall") or ""
+    pending = []
+    for line in status.splitlines():
+        if len(line) < 4:
+            continue
+        code, path = line[:2], line[3:]
+        if " -> " in path:
+            path = path.split(" -> ", 1)[1]
+        if path.strip('"').startswith(exclude):
+            continue
+        kind = "added" if "?" in code or "A" in code else "deleted" if "D" in code else "modified"
+        pending.append({"path": path.strip('"'), "status": kind, "category": categorise(path, categories)})
+    if pending:
+        commits.append({"hash": "", "short": "", "author": "", "date": "", "subject": "Uncommitted changes",
+                        "files": pending, "pending": True})
+
+    out = _git(root, "log", f"-n{limit}", "--name-status", "--no-renames", "--format=%x1e%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1f%P")
+    for block in (out or "").split("\x1e"):
+        if not block.strip():
+            continue
+        header, _, rest = block.partition("\n")
+        full, short, author, date, subject, parents = (header.split("\x1f") + [""] * 6)[:6]
+        files = []
+        for line in rest.splitlines():
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+            path = parts[-1]
+            if path.startswith(exclude):
+                continue
+            files.append({"path": path, "status": _STATUS.get(parts[0][:1], "modified"),
+                          "category": categorise(path, categories)})
+        commits.append({"hash": full, "short": short, "author": author, "date": date, "subject": subject,
+                        "files": files, "merge": len(parents.split()) > 1})
+    branch = (_git(root, "rev-parse", "--abbrev-ref", "HEAD") or "").strip()
+    return {"available": True, "branch": branch, "commits": commits}

rdstudio/launcher.py

@@ -0,0 +1,63 @@
+"""The ``rdstudio`` command: runs the Node command line (packages/cli in the
+repository), bundled into this package at release, with Node from the
+``nodejs-wheel-binaries`` dependency, so ``uv tool install rdstudio`` needs
+nothing else.
+
+- In a checkout (an editable install), the TypeScript sources run directly.
+- ``RDSTUDIO_PYTHON=1`` (or the ``rdstudio-py`` command) runs the Python
+  command line instead, while it lasts; so does a missing Node program.
+- ``RDSTUDIO_NODE`` names another node executable (24 or later).
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+BUNDLE = HERE / "_node" / "rdstudio.mjs"  # built by `npm run bundle --workspace rdstudio`
+SOURCE = HERE.parent.parent / "packages" / "cli" / "src" / "main.ts"  # present in a checkout
+
+
+def node_executable() -> str | None:
+    if os.environ.get("RDSTUDIO_NODE"):
+        return os.environ["RDSTUDIO_NODE"]
+    try:
+        from nodejs_wheel import executable
+    except ImportError:
+        return shutil.which("node")
+    return os.path.join(executable.ROOT_DIR, "node.exe" if os.name == "nt" else os.path.join("bin", "node"))
+
+
+def program() -> Path | None:
+    """The Node program to run: the sources in a checkout, else the bundle."""
+    if SOURCE.is_file() and (SOURCE.parents[3] / "node_modules").is_dir():  # the repository root
+        return SOURCE
+    return BUNDLE if BUNDLE.is_file() else None
+
+
+def python_cli() -> None:
+    from .cli import main as python_main
+
+    sys.exit(python_main())
+
+
+def main() -> None:
+    if os.environ.get("RDSTUDIO_PYTHON"):
+        python_cli()
+    script, node = program(), node_executable()
+    if script is None or node is None:
+        print("rdstudio: the Node command line is not available here; using the Python one.", file=sys.stderr)
+        python_cli()
+    env = {**os.environ, "RDSTUDIO_WEB_DIR": str(HERE / "web"), "RDSTUDIO_TEMPLATES_DIR": str(HERE / "templates")}
+    args = [node, str(script), *sys.argv[1:]]
+    if os.name == "posix":
+        os.execve(node, args, env)  # hand over the process: stdio for MCP, signals for serve
+    sys.exit(subprocess.run(args, env=env).returncode)
+
+
+if __name__ == "__main__":
+    main()