simple-module-cli 0.0.30__tar.gz → 0.0.32__tar.gz

{simple_module_cli-0.0.30 → simple_module_cli-0.0.32}/.gitignore

@@ -63,3 +63,4 @@ Thumbs.db
 host/client_app/.playwright-cli/*
 .superpowers/
 .qa/
+.verify/

{simple_module_cli-0.0.30 → simple_module_cli-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: simple_module_cli
-Version: 0.0.30
+Version: 0.0.32
 Summary: Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host.
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python

{simple_module_cli-0.0.30 → simple_module_cli-0.0.32}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_cli"
-version = "0.0.30"
+version = "0.0.32"
 description = "Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host."
 readme = "README.md"
 license = "MIT"

simple_module_cli-0.0.32/simple_module_cli/add_cmd.py

@@ -0,0 +1,267 @@
+"""``smpy add`` — add a module from PyPI, any git repo, or a local path.
+
+Git specs: ``git+<url>[@<tag|branch|sha>][#subdirectory=<dir>]``. The spec
+is resolved first (ls-remote + shallow clone + entry-point scan); the host
+pyproject is written only after resolution succeeds. A git spec without
+``#subdirectory`` is scanned for module packages — one match is added
+directly, several go through ``--module``/``--all`` or an interactive
+picker. Then: ``uv sync`` → ``smpy host gen-pages`` → ``smpy host
+sync-js-deps`` → entry-point verification, unless ``--no-sync``.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from collections.abc import Callable
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from simple_module_cli.git_source import (
+    FoundModule,
+    SpecError,
+    classify_ref,
+    derive_range,
+    parse_add_spec,
+    scan_modules,
+    shallow_clone,
+)
+from simple_module_cli.pyproject_edit import (
+    has_git_sources,
+    load_pyproject,
+    save_pyproject,
+    write_dependency,
+    write_git_source,
+    write_path_source,
+)
+
+__all__ = ["ExecRunner", "add_module", "post_install", "run_add"]
+
+ExecRunner = Callable[[list[str], Path], int]
+
+_SECURITY_NOTICE = (
+    "note: this installs and runs code from a URL you chose — review the "
+    "repository before booting the host."
+)
+
+_ENTRYPOINT_CHECK = (
+    "import sys\n"
+    "from importlib.metadata import distributions\n"
+    "target = sys.argv[1].replace('-', '_').lower()\n"
+    "for dist in distributions():\n"
+    "    if any(ep.group == 'simple_module' for ep in dist.entry_points):\n"
+    "        name = (dist.metadata['Name'] or '').replace('-', '_').lower()\n"
+    "        if name == target:\n"
+    "            sys.exit(0)\n"
+    "sys.exit(1)\n"
+)
+
+
+def _default_exec_runner(cmd: list[str], cwd: Path) -> int:
+    return subprocess.run(cmd, cwd=cwd, check=False).returncode
+
+
+def _fail(message: str) -> typer.Exit:
+    typer.echo(f"ERROR: {message}", err=True)
+    return typer.Exit(code=1)
+
+
+def _choose(
+    found: list[FoundModule],
+    *,
+    select: list[str] | None,
+    all_modules: bool,
+    assume_yes: bool,
+) -> list[FoundModule]:
+    if len(found) == 1:
+        return found
+    if all_modules:
+        return found
+    if select:
+        wanted = {s.replace("-", "_").lower() for s in select}
+        chosen = [m for m in found if m.dist_name.replace("-", "_").lower() in wanted]
+        missing = wanted - {m.dist_name.replace("-", "_").lower() for m in chosen}
+        if missing:
+            raise _fail(f"module(s) not found in repo: {', '.join(sorted(missing))}")
+        return chosen
+    if assume_yes:
+        names = ", ".join(m.dist_name for m in found)
+        raise _fail(f"repo contains multiple modules ({names}); pick with --module a,b or --all")
+    return [
+        m
+        for m in found
+        if typer.confirm(f"Include {m.dist_name} ({m.subdirectory or 'repo root'})?")
+    ]
+
+
+def post_install(
+    project_dir: Path,
+    dists: list[str],
+    models_dists: list[str],
+    exec_runner: ExecRunner,
+) -> None:
+    """uv sync → gen-pages → sync-js-deps → entry-point check → reminders."""
+    if exec_runner(["uv", "sync"], project_dir) != 0:
+        raise _fail("`uv sync` failed — pyproject was written; fix and re-run `uv sync`.")
+    if (project_dir / "client_app").is_dir():
+        exec_runner(["uv", "run", "smpy", "host", "gen-pages"], project_dir)
+        exec_runner(["uv", "run", "smpy", "host", "sync-js-deps"], project_dir)
+    for dist in dists:
+        code = exec_runner(["uv", "run", "python", "-c", _ENTRYPOINT_CHECK, dist], project_dir)
+        if code != 0:
+            raise _fail(
+                f"{dist} installed but exposes no [project.entry-points.simple_module] "
+                "entry point — it is not a SimpleModule module."
+            )
+    for dist in models_dists:
+        typer.echo(
+            f"{dist} ships database models — generate and apply the migration:\n"
+            f'  make migration msg="add {dist}"\n  make migrate'
+        )
+
+
+def _add_pypi(doc, pyproject: Path, raw: str, no_sync: bool, exec_runner: ExecRunner) -> list[str]:
+    name = raw
+    for i, ch in enumerate(raw):
+        if ch in "<>=!~[; ":
+            name = raw[:i]
+            break
+    constraint = raw[len(name) :]
+    write_dependency(doc, name, constraint)
+    save_pyproject(pyproject, doc)
+    typer.echo(f"Added {name} (PyPI).")
+    if not no_sync:
+        post_install(pyproject.parent, [name], [], exec_runner)
+    return [name]
+
+
+def _add_path(
+    doc, pyproject: Path, spec_path: Path, no_sync: bool, exec_runner: ExecRunner
+) -> list[str]:
+    root = spec_path if spec_path.is_absolute() else pyproject.parent / spec_path
+    found = [m for m in scan_modules(root) if m.subdirectory is None]
+    if not found:
+        raise _fail(f"{root} has no [project.entry-points.simple_module] entry point at its root")
+    mod = found[0]
+    write_dependency(doc, mod.dist_name, derive_range(mod.version))
+    write_path_source(doc, mod.dist_name, path=str(spec_path))
+    save_pyproject(pyproject, doc)
+    typer.echo(f"Added {mod.dist_name} (editable path {spec_path}).")
+    if not no_sync:
+        post_install(
+            pyproject.parent,
+            [mod.dist_name],
+            [mod.dist_name] if mod.ships_models else [],
+            exec_runner,
+        )
+    return [mod.dist_name]
+
+
+def run_add(
+    spec: str,
+    *,
+    pyproject: Path,
+    select: list[str] | None = None,
+    all_modules: bool = False,
+    no_sync: bool = False,
+    assume_yes: bool = False,
+    git_runner=None,
+    exec_runner: ExecRunner | None = None,
+) -> list[str]:
+    if not pyproject.is_file():
+        raise _fail(f"{pyproject} not found")
+    exec_runner = exec_runner or _default_exec_runner
+    try:
+        parsed = parse_add_spec(spec)
+    except SpecError as exc:
+        raise _fail(str(exc)) from exc
+    doc = load_pyproject(pyproject)
+
+    if parsed.kind == "pypi":
+        return _add_pypi(doc, pyproject, parsed.raw, no_sync, exec_runner)
+    if parsed.kind == "path":
+        assert parsed.path is not None
+        return _add_path(doc, pyproject, parsed.path, no_sync, exec_runner)
+
+    assert parsed.git is not None
+    git_kwargs = {"run": git_runner} if git_runner else {}
+    ref_info = classify_ref(parsed.git.url, parsed.git.ref, **git_kwargs)
+    with tempfile.TemporaryDirectory(prefix="smpy-add-") as tmp:
+        clone = shallow_clone(parsed.git.url, ref_info, Path(tmp) / "repo", **git_kwargs)
+        found = scan_modules(clone)
+    if parsed.git.subdirectory is not None:
+        found = [m for m in found if m.subdirectory == parsed.git.subdirectory]
+    if not found:
+        where = (
+            f"subdirectory {parsed.git.subdirectory!r} of {parsed.git.url}"
+            if parsed.git.subdirectory
+            else parsed.git.url
+        )
+        raise _fail(f"{where} has no package declaring [project.entry-points.simple_module]")
+    chosen = _choose(found, select=select, all_modules=all_modules, assume_yes=assume_yes)
+    if not chosen:
+        raise _fail("no modules selected")
+
+    if not has_git_sources(doc):
+        typer.echo(_SECURITY_NOTICE)
+    for mod in chosen:
+        write_dependency(doc, mod.dist_name, derive_range(mod.version))
+        write_git_source(
+            doc,
+            mod.dist_name,
+            url=parsed.git.url,
+            ref_info=ref_info,
+            subdirectory=mod.subdirectory,
+        )
+        pin = f"{ref_info.kind} {ref_info.value}" if ref_info.value else "default branch"
+        typer.echo(f"Added {mod.dist_name} {mod.version} from git ({pin}).")
+        if ref_info.kind == "branch":
+            typer.echo(
+                f"  {mod.dist_name} tracks a branch — dev-mode pin; prefer a v* tag for releases."
+            )
+    save_pyproject(pyproject, doc)
+    if not no_sync:
+        post_install(
+            pyproject.parent,
+            [m.dist_name for m in chosen],
+            [m.dist_name for m in chosen if m.ships_models],
+            exec_runner,
+        )
+    return [m.dist_name for m in chosen]
+
+
+def add_module(
+    spec: Annotated[
+        str,
+        typer.Argument(help="PyPI requirement, git+URL[@ref][#subdirectory=dir], or local path."),
+    ],
+    module: Annotated[
+        str,
+        typer.Option("--module", help="Comma-separated module dist names (multi-module repos)."),
+    ] = "",
+    all_modules: Annotated[
+        bool, typer.Option("--all", help="Add every module found in the repo.")
+    ] = False,
+    path: Annotated[
+        Path,
+        typer.Option("--path", help="Project root or pyproject.toml. Defaults to cwd."),
+    ] = Path(),
+    no_sync: Annotated[
+        bool,
+        typer.Option("--no-sync", help="Write pyproject only; skip uv sync / gen-pages."),
+    ] = False,
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Never prompt (fail instead).")] = False,
+) -> None:
+    """Add a module dependency from PyPI, a git repo, or a local path."""
+    pyproject = path if path.name == "pyproject.toml" else path / "pyproject.toml"
+    select = [m.strip() for m in module.split(",") if m.strip()]
+    run_add(
+        spec,
+        pyproject=pyproject,
+        select=select or None,
+        all_modules=all_modules,
+        no_sync=no_sync,
+        assume_yes=yes,
+    )

{simple_module_cli-0.0.30 → simple_module_cli-0.0.32}/simple_module_cli/cli.py

@@ -2,6 +2,8 @@
 
 Built-in commands:
   smpy new
+  smpy add
+  smpy update
   smpy create-host
   smpy create-module
   smpy skills add / list / update
@@ -17,6 +19,7 @@ from typing import Annotated
 
 import typer
 
+from simple_module_cli.add_cmd import add_module, run_add
 from simple_module_cli.case import to_kebab_case
 from simple_module_cli.module_cmd import module_app
 from simple_module_cli.new import new_project
@@ -26,6 +29,7 @@ from simple_module_cli.scaffolding import create_host as _create_host
 from simple_module_cli.scaffolding import create_module as _create_module
 from simple_module_cli.scaffolding import is_inside_existing_repo, resolve_framework_version
 from simple_module_cli.skills_cmd import app as skills_app
+from simple_module_cli.update_cmd import update_modules
 
 app = typer.Typer(
     help="SimpleModule developer CLI.",
@@ -34,6 +38,8 @@ app = typer.Typer(
 )
 
 app.command("new")(new_project)
+app.command("add")(add_module)
+app.command("update")(update_modules)
 app.command("package-update")(package_update)
 app.add_typer(skills_app, name="skills")
 app.add_typer(module_app, name="module")
@@ -53,6 +59,14 @@ def create_host(
             help="Comma-separated module names to declare as deps (e.g. Auth,Dashboard).",
         ),
     ] = "",
+    git_module: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--git-module",
+            help="git+URL[@ref][#subdirectory=dir] module source; repeatable. "
+            "Multi-module repos need an explicit #subdirectory here.",
+        ),
+    ] = None,
 ) -> None:
     """Scaffold a new SimpleModule host project at ./<NAME>."""
     target = dest or Path.cwd() / name
@@ -73,6 +87,10 @@ def create_host(
         typer.echo(f"ERROR: {exc}", err=True)
         raise typer.Exit(code=1) from exc
 
+    # create-host is non-interactive: multi-module repos need #subdirectory.
+    for spec in git_module or []:
+        run_add(spec, pyproject=target / "pyproject.toml", no_sync=True, assume_yes=True)
+
     typer.echo(f"Created host '{name}' at {target}")
     if selected:
         typer.echo(f"Declared modules: {', '.join(selected)}")

simple_module_cli-0.0.32/simple_module_cli/git_source.py

@@ -0,0 +1,282 @@
+"""Parsing and git-side resolution for ``smpy add`` / ``smpy update``.
+
+A git module source is a normal named dependency plus a ``[tool.uv.sources]``
+redirect. This module owns everything before the host pyproject is written:
+parsing the spec string, classifying ``@ref`` against the remote, shallow
+cloning for metadata, and scanning a clone for module packages.
+
+Stdlib + the ``git`` binary only: the CLI distribution depends on typer +
+tomlkit alone (see test_no_framework_deps.py); clones are read with tomllib.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import tomllib
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+__all__ = [
+    "FoundModule",
+    "GitAddSpec",
+    "ParsedSpec",
+    "RefInfo",
+    "SpecError",
+    "classify_ref",
+    "derive_range",
+    "list_remote_refs",
+    "parse_add_spec",
+    "pick_latest_tag",
+    "satisfies",
+    "scan_modules",
+    "shallow_clone",
+    "version_tuple",
+]
+
+GitRunner = Callable[..., str]
+
+
+class SpecError(ValueError):
+    """Malformed or unsupported `smpy add` spec."""
+
+
+@dataclass(frozen=True)
+class GitAddSpec:
+    url: str
+    ref: str | None
+    subdirectory: str | None
+
+
+@dataclass(frozen=True)
+class ParsedSpec:
+    kind: Literal["pypi", "git", "path"]
+    raw: str
+    git: GitAddSpec | None = None
+    path: Path | None = None
+
+
+def parse_add_spec(spec: str) -> ParsedSpec:
+    raw = spec.strip()
+    if not raw:
+        raise SpecError("empty spec")
+    if raw.startswith("git+"):
+        return ParsedSpec("git", raw, git=_parse_git(raw))
+    if raw.startswith((".", "/", "~")):
+        return ParsedSpec("path", raw, path=Path(raw).expanduser())
+    if "://" in raw:
+        raise SpecError(f"unsupported URL {raw!r}: git sources must start with git+")
+    return ParsedSpec("pypi", raw)
+
+
+def _parse_git(raw: str) -> GitAddSpec:
+    body = raw[len("git+") :]
+    subdirectory: str | None = None
+    if "#" in body:
+        body, fragment = body.split("#", 1)
+        for part in fragment.split("&"):
+            if part.startswith("subdirectory="):
+                subdirectory = part[len("subdirectory=") :] or None
+            elif part:
+                raise SpecError(
+                    f"unsupported fragment {part!r}: only subdirectory=<dir> is understood"
+                )
+    ref: str | None = None
+    head, sep, tail = body.rpartition("@")
+    # `@` also appears in URL userinfo (ssh://git@host/...). A ref candidate
+    # never contains "/" and what precedes it must still be a full URL.
+    if sep and tail and "/" not in tail and "://" in head:
+        body, ref = head, tail
+    if "://" not in body:
+        raise SpecError(f"cannot parse a git URL out of {raw!r}")
+    return GitAddSpec(url=body, ref=ref, subdirectory=subdirectory)
+
+
+# --- version helpers (no `packaging` dep — CLI depends on typer + tomlkit only) ---
+
+
+def version_tuple(v: str) -> tuple[int, ...]:
+    parts: list[int] = []
+    for part in v.split("."):
+        digits = ""
+        for ch in part:
+            if ch.isdigit():
+                digits += ch
+            else:
+                break
+        parts.append(int(digits) if digits else 0)
+    return tuple(parts)
+
+
+def _cmp(a: str, b: str) -> int:
+    ta, tb = version_tuple(a), version_tuple(b)
+    width = max(len(ta), len(tb))
+    ta += (0,) * (width - len(ta))
+    tb += (0,) * (width - len(tb))
+    return (ta > tb) - (ta < tb)
+
+
+_OPS = ("<=", ">=", "==", "!=", "<", ">")
+
+
+def satisfies(version: str, constraint: str) -> bool:
+    for clause in constraint.split(","):
+        clause = clause.strip()
+        if not clause:
+            continue
+        for op in _OPS:
+            if clause.startswith(op):
+                bound = clause[len(op) :].strip()
+                c = _cmp(version, bound)
+                ok = {
+                    "<=": c <= 0,
+                    ">=": c >= 0,
+                    "==": c == 0,
+                    "!=": c != 0,
+                    "<": c < 0,
+                    ">": c > 0,
+                }[op]
+                if not ok:
+                    return False
+                break
+        else:
+            return False
+    return True
+
+
+def derive_range(version: str) -> str:
+    major = version_tuple(version)[0]
+    upper = "1.0" if major == 0 else f"{major + 1}.0"
+    return f">={version},<{upper}"
+
+
+def pick_latest_tag(tags: Iterable[str], constraint: str | None) -> str | None:
+    best: str | None = None
+    for tag in tags:
+        if not tag.startswith("v") or len(tag) < 2 or not tag[1].isdigit():
+            continue
+        ver = tag[1:]
+        if constraint and not satisfies(ver, constraint):
+            continue
+        if best is None or _cmp(ver, best[1:]) > 0:
+            best = tag
+    return best
+
+
+# --- remote resolution + clone scanning ---
+
+
+@dataclass(frozen=True)
+class RefInfo:
+    kind: Literal["tag", "branch", "rev", "default"]
+    value: str | None
+
+
+@dataclass(frozen=True)
+class FoundModule:
+    dist_name: str
+    version: str
+    subdirectory: str | None
+    ships_models: bool
+    framework_range: str | None
+
+
+def _default_git_runner(args: list[str], cwd: Path | None = None) -> str:
+    result = subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True, text=True)
+    return result.stdout
+
+
+def list_remote_refs(
+    url: str, *, run: GitRunner = _default_git_runner
+) -> tuple[set[str], set[str]]:
+    out = run(["ls-remote", "--tags", "--heads", url])
+    tags: set[str] = set()
+    branches: set[str] = set()
+    for line in out.splitlines():
+        parts = line.split("\t")
+        if len(parts) != 2:
+            continue
+        ref = parts[1].removesuffix("^{}")
+        if ref.startswith("refs/tags/"):
+            tags.add(ref.removeprefix("refs/tags/"))
+        elif ref.startswith("refs/heads/"):
+            branches.add(ref.removeprefix("refs/heads/"))
+    return tags, branches
+
+
+def classify_ref(url: str, ref: str | None, *, run: GitRunner = _default_git_runner) -> RefInfo:
+    if ref is None:
+        return RefInfo("default", None)
+    tags, branches = list_remote_refs(url, run=run)
+    if ref in tags:
+        return RefInfo("tag", ref)
+    if ref in branches:
+        return RefInfo("branch", ref)
+    return RefInfo("rev", ref)
+
+
+def shallow_clone(
+    url: str, ref_info: RefInfo, dest: Path, *, run: GitRunner = _default_git_runner
+) -> Path:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    base = ["clone", "--depth", "1", "--quiet"]
+    if ref_info.kind in ("tag", "branch") and ref_info.value:
+        run([*base, "--branch", ref_info.value, url, str(dest)])
+    elif ref_info.kind == "rev" and ref_info.value:
+        # --branch can't take a SHA; fetch the rev into a fresh clone instead.
+        run([*base, url, str(dest)])
+        run(["fetch", "--depth", "1", "origin", ref_info.value], cwd=dest)
+        run(["checkout", "--quiet", "FETCH_HEAD"], cwd=dest)
+    else:
+        run([*base, url, str(dest)])
+    return dest
+
+
+_SKIP_DIRS = {".git", "node_modules", ".venv", "__pycache__", "dist", "build"}
+
+
+def _framework_range(deps: list[str]) -> str | None:
+    for dep in deps:
+        text = str(dep).strip()
+        if text.replace("-", "_").startswith("simple_module_core"):
+            for i, ch in enumerate(text):
+                if ch in "<>=!~":
+                    return text[i:].strip()
+    return None
+
+
+def scan_modules(repo_root: Path) -> list[FoundModule]:
+    """Find every package in the clone declaring the simple_module entry point."""
+    candidates: list[Path] = []
+    for pattern in ("pyproject.toml", "*/pyproject.toml", "*/*/pyproject.toml"):
+        candidates.extend(sorted(repo_root.glob(pattern)))
+    found: list[FoundModule] = []
+    for pyproject in candidates:
+        rel_parts = pyproject.relative_to(repo_root).parts
+        if any(part in _SKIP_DIRS for part in rel_parts):
+            continue
+        try:
+            data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+        except (OSError, tomllib.TOMLDecodeError):
+            continue
+        project = data.get("project") or {}
+        entry_points = project.get("entry-points") or {}
+        if "simple_module" not in entry_points or "name" not in project:
+            continue
+        pkg_root = pyproject.parent
+        subdirectory = None if pkg_root == repo_root else "/".join(rel_parts[:-1])
+        ships_models = any(
+            not any(part in _SKIP_DIRS for part in p.relative_to(pkg_root).parts)
+            for p in pkg_root.glob("*/models.py")
+        )
+        found.append(
+            FoundModule(
+                dist_name=str(project["name"]),
+                version=str(project.get("version", "0")),
+                subdirectory=subdirectory,
+                ships_models=ships_models,
+                framework_range=_framework_range(project.get("dependencies") or []),
+            )
+        )
+    return found