stml-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{stml_cli-0.1.2 → stml_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stml-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: The stml partner CLI — pull, edit, push, and publish stml apps and libraries.
 Author: stml
 Project-URL: Homepage, https://stml.io

{stml_cli-0.1.2 → stml_cli-0.1.4}/stml_cli/__init__.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import os
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 # TLS trust: framework/python.org builds have no OpenSSL CA path, so a real
 # https backend fails with "unable to get local issuer certificate". certifi's

{stml_cli-0.1.2 → stml_cli-0.1.4}/stml_cli/commands.py

@@ -70,16 +70,30 @@ def cmd_list(args) -> None:
     if not apps:
         _log("No apps found.")
         return
-    # Display name + mode (035: attached/detached/scratch) + the app URL — the
-    # exact handle `stml pull`/`push` accept (the URL's app slug is unique, so
-    # it never collides even when a library is installed twice). Rows to stdout
-    # so `stml list | grep …` works; header to stderr.
-    name_w = max(len(a.get("name") or "") for a in apps)
+    # Name + org + workspace + mode (035: attached/detached/scratch) + the app
+    # URL — the exact handle `stml pull`/`push` accept (the URL's app slug is
+    # unique, so it never collides even when a library is installed twice). Org
+    # and workspace disambiguate same-named apps across the account. Names fall
+    # back to slugs against older backends. Rows to stdout so `stml list | grep …`
+    # works; header to stderr.
+    def _org(a):
+        return a.get("org_name") or a.get("org_slug") or ""
+
+    def _ws(a):
+        return a.get("workspace_name") or a.get("workspace_slug") or ""
+
+    name_w = max((len(a.get("name") or "") for a in apps), default=3)
+    org_w = max((len(_org(a)) for a in apps), default=3)
+    ws_w = max((len(_ws(a)) for a in apps), default=2)
     mode_w = max((len(a.get("mode") or "") for a in apps), default=4)
-    _log(f"{'APP'.ljust(name_w)}  {'MODE'.ljust(mode_w)}  URL")
+    _log(
+        f"{'APP'.ljust(name_w)}  {'ORG'.ljust(org_w)}  "
+        f"{'WORKSPACE'.ljust(ws_w)}  {'MODE'.ljust(mode_w)}  URL"
+    )
     for a in apps:
         print(
             f"{(a.get('name') or '').ljust(name_w)}  "
+            f"{_org(a).ljust(org_w)}  {_ws(a).ljust(ws_w)}  "
             f"{(a.get('mode') or '').ljust(mode_w)}  {a.get('url') or ''}"
         )
 
@@ -238,6 +252,12 @@ def cmd_publish(args) -> None:
     if not org_slug:
         raise SystemExit("Pass --org or set [tool.stml].issuer-org in pyproject.toml")
 
+    # Pre-flight: show the resolved coordinate BEFORE uploading, and say where
+    # the issuer came from — a pulled fork silently carries the ORIGINAL
+    # issuer-org in its pyproject, which is exactly when you want `--org`.
+    origin = "--org" if args.org else "[tool.stml].issuer-org in pyproject.toml"
+    _log(f"Publishing as {org_slug}/{name}@{version}  (issuer from {origin})")
+
     token = http.resolve_token(args.backend)
 
     # Ensure the library exists (409 = already there, which is fine).

{stml_cli-0.1.2 → stml_cli-0.1.4}/stml_cli/packaging.py

@@ -4,6 +4,12 @@ One directory → a ``<dir-name>/…`` gzip tarball, excluding local dev junk. T
 platform publish endpoint reads the manifest and explodes ``src/``; this only
 packages the bytes. Kept byte-compatible with the monorepo builder so a lib
 published by either path lands identically.
+
+The publish process deliberately stays layout-strict (src/ required for
+runnable Python — story 020's guard): a folder made by ``stml pull`` is
+ALREADY written in the src/ library layout (the overlay's flat keys are a
+platform-internal storage detail — see ``paths.write_tree``), so a pulled
+fork publishes here without repackaging.
 """
 
 from __future__ import annotations
@@ -13,7 +19,7 @@ import tarfile
 from pathlib import Path
 
 EXCLUDE_DIRS = {
-    ".git", ".venv", "venv", "__pycache__", "node_modules", ".pytest_cache",
+    ".git", ".stml", ".venv", "venv", "__pycache__", "node_modules", ".pytest_cache",
     "dist", "build", ".mypy_cache", ".ruff_cache",
     # Unit tests live in a top-level tests/ per lib (pytest testpaths); test-
     # named files inside packages are intentional runnable flows, so dir-only.

stml_cli-0.1.4/stml_cli/paths.py

@@ -0,0 +1,125 @@
+"""Cross-platform overlay ↔ local-folder mapping (024 §OS & runtime support).
+
+The overlay keys the platform stores are always POSIX (``flows/x.py``). "Runs on
+Windows" is only real if the CLI:
+  1. maps a POSIX key to a NATIVE path when writing to disk, and back to a POSIX
+     key (never backslashes) when reading — via ``PurePosixPath`` on the wire,
+     ``Path`` on disk;
+  2. reads/writes UTF-8 and preserves ``\n`` exactly, so a pulled file survives
+     an untouched push byte-for-byte (no CRLF injection on Windows).
+
+Layout mapping (authoring vs deploying): on DISK the CLI presents the standard
+**src/ library layout** — the same shape as a real library repo, what
+``stml publish`` expects, and what a human authors. The platform's overlay
+stores the FLAT deploy-side keys (``pkg/flow.py``); that is an internal storage
+detail that must not leak to disk. So:
+
+  * ``write_tree`` (pull)  — a flat overlay with Python is written with its
+    runnable files under ``src/`` (packaging/metadata — pyproject, top-level
+    ``*.md``, ``page/**``, LICENSE — stays at the root, mirroring the publish
+    tarball layout and the server's ``_is_packaging_path``).
+  * ``read_tree`` (push)   — a folder with a top-level ``src/`` has that prefix
+    stripped back to the flat overlay keys, so an overlay row always shadows
+    its base-library path exactly. A flat folder (pre-mapping pulls, hand-made
+    trees) passes through unchanged.
+
+The two directions are inverse by construction, so pull → push is lossless.
+
+These functions are the whole contract; they are unit-tested in isolation so
+the Windows guarantee doesn't rest on a live round-trip.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+
+
+def _is_packaging_path(rel: str) -> bool:
+    """Paths that live at the ROOT in the src-layout view (not under ``src/``) —
+    metadata the publish endpoint reads there and the deploy bundler ignores.
+    Must match the server's ``_is_packaging_path`` so the disk layout equals
+    the publish-tarball layout."""
+    if rel in ("pyproject.toml", "README.md", "LICENSE", "py.typed"):
+        return True
+    if rel.startswith("page/"):           # app-page assets, served separately
+        return True
+    if "/" not in rel and rel.endswith(".md"):  # top-level docs incl. AGENTS.md
+        return True
+    return False
+
+# Local-only artifacts that must never be pushed into the overlay.
+_EXCLUDE_DIRS = {
+    ".git", "__pycache__", ".venv", "venv", ".stml",
+    "node_modules", ".mypy_cache", ".ruff_cache", ".pytest_cache",
+}
+_EXCLUDE_NAMES = {".DS_Store"}
+_EXCLUDE_SUFFIXES = {".pyc", ".pyo"}
+
+
+def to_posix_key(rel: Path) -> str:
+    """A native relative path → the POSIX overlay key (forward slashes)."""
+    return PurePosixPath(*rel.parts).as_posix()
+
+
+def key_to_native(key: str) -> Path:
+    """A POSIX overlay key → a native relative Path for this OS."""
+    return Path(*PurePosixPath(key).parts)
+
+
+def read_tree(root: Path) -> list[dict]:
+    """Read a local folder into ``[{path, content}]`` with POSIX overlay keys.
+
+    A top-level ``src/`` (the on-disk library layout ``write_tree`` produces)
+    is stripped back to the flat overlay keys — the canonical form the platform
+    stores, and the form in which an overlay row shadows its base-library path.
+    A same-key collision (``src/pkg/x.py`` next to ``pkg/x.py``) is ambiguous
+    and raises rather than silently picking a winner.
+
+    ``read_text`` (universal newlines) collapses any CRLF to ``\n``, so the
+    content pushed is always LF-normalised regardless of the author's OS.
+    """
+    out: list[dict] = []
+    seen: dict[str, str] = {}  # overlay key → original rel (collision detection)
+    for p in sorted(root.rglob("*")):
+        rel = p.relative_to(root)
+        if any(part in _EXCLUDE_DIRS for part in rel.parts):
+            continue
+        if p.name in _EXCLUDE_NAMES or p.suffix in _EXCLUDE_SUFFIXES:
+            continue
+        if not p.is_file():
+            continue
+        key = to_posix_key(rel)
+        if key.startswith("src/"):
+            key = key[len("src/"):]
+        if key in seen:
+            raise ValueError(
+                f"ambiguous tree: {rel.as_posix()!r} and {seen[key]!r} both map to "
+                f"overlay key {key!r} — keep runnable code under src/ only."
+            )
+        seen[key] = rel.as_posix()
+        out.append({"path": key, "content": p.read_text(encoding="utf-8")})
+    return out
+
+
+def write_tree(root: Path, files: list[dict]) -> list[str]:
+    """Write ``[{path, content}]`` (POSIX overlay keys) into a local folder in
+    the standard **src/ library layout**: when the overlay carries Python (and
+    isn't already src-laid-out), runnable files land under ``src/`` and
+    packaging/metadata stays at the root — so the folder is a valid library
+    directory (`stml publish` accepts it as-is) and diffs cleanly against a
+    real library repo. Returns the overlay keys written (not disk paths).
+
+    ``newline=""`` disables newline translation so ``\n`` is written verbatim —
+    a pulled file is not silently rewritten to CRLF on Windows.
+    """
+    py_keys = [f["path"] for f in files if f["path"].endswith(".py")]
+    relocate = bool(py_keys) and not any(k.startswith("src/") for k in py_keys)
+    written: list[str] = []
+    for f in files:
+        key = f["path"]
+        disk_key = f"src/{key}" if relocate and not _is_packaging_path(key) else key
+        dest = root / key_to_native(disk_key)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(f.get("content") or "", encoding="utf-8", newline="")
+        written.append(key)
+    return written

{stml_cli-0.1.2 → stml_cli-0.1.4}/stml_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stml-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: The stml partner CLI — pull, edit, push, and publish stml apps and libraries.
 Author: stml
 Project-URL: Homepage, https://stml.io

stml_cli-0.1.4/tests/test_paths.py

@@ -0,0 +1,120 @@
+"""Cross-platform overlay ↔ folder mapping (024 acceptance: CLI cross-platform).
+
+The Windows guarantee ("a pulled tree round-trips; overlay keys stay POSIX and
+content stays UTF-8/\\n") rests entirely on paths.read_tree / write_tree, so
+they are pinned here in isolation — no live backend, no OS assumptions.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from stml_cli import paths
+
+
+def test_keys_are_posix_even_for_nested_paths(tmp_path: Path):
+    files = [
+        {"path": "flows/greeting.py", "content": "print('hi')\n"},
+        {"path": "page/index.html", "content": "<h1>hi</h1>\n"},
+        {"path": "pyproject.toml", "content": "[project]\n"},
+    ]
+    paths.write_tree(tmp_path, files)
+    # On disk: the standard src/ library layout — runnable Python under src/,
+    # packaging (page/, pyproject) at the root (authoring vs deploying: the
+    # flat overlay key is a platform-internal storage detail).
+    assert (tmp_path / "src" / "flows" / "greeting.py").is_file()
+    assert (tmp_path / "page" / "index.html").is_file()
+    assert (tmp_path / "pyproject.toml").is_file()
+    # ...but reading back yields the flat forward-slash overlay keys.
+    keys = {f["path"] for f in paths.read_tree(tmp_path)}
+    assert keys == {"flows/greeting.py", "page/index.html", "pyproject.toml"}
+    assert not any("\\" in k for k in keys)
+
+
+def test_page_only_overlay_stays_flat_on_disk(tmp_path: Path):
+    """No Python in the overlay (fresh attached install) → nothing to wrap."""
+    paths.write_tree(tmp_path, [{"path": "page/index.html", "content": "<h1/>\n"}])
+    assert (tmp_path / "page" / "index.html").is_file()
+    assert not (tmp_path / "src").exists()
+
+
+def test_src_layout_folder_pushes_flat_keys(tmp_path: Path):
+    """A real library folder (hand-made or pulled) pushes the FLAT overlay keys,
+    so an overlay row shadows its base-library path exactly."""
+    (tmp_path / "src" / "pkg").mkdir(parents=True)
+    (tmp_path / "src" / "pkg" / "x.py").write_text("x = 1\n")
+    (tmp_path / "pyproject.toml").write_text("[project]\n")
+    keys = {f["path"] for f in paths.read_tree(tmp_path)}
+    assert keys == {"pkg/x.py", "pyproject.toml"}
+
+
+def test_flat_folder_passes_through_unchanged(tmp_path: Path):
+    """Pre-mapping pulls / hand-made flat trees keep working (no src/ → no strip)."""
+    (tmp_path / "pkg").mkdir()
+    (tmp_path / "pkg" / "x.py").write_text("x = 1\n")
+    keys = {f["path"] for f in paths.read_tree(tmp_path)}
+    assert keys == {"pkg/x.py"}
+
+
+def test_pull_push_round_trip_is_lossless(tmp_path: Path):
+    files = [
+        {"path": "pkg/flow.py", "content": "F = 1\n"},
+        {"path": "pkg/data.csv", "content": "a,b\n"},
+        {"path": "page/index.html", "content": "<h1/>\n"},
+        {"path": "AGENTS.md", "content": "# doc\n"},
+        {"path": "pyproject.toml", "content": "[project]\n"},
+    ]
+    paths.write_tree(tmp_path, files)
+    got = sorted(paths.read_tree(tmp_path), key=lambda f: f["path"])
+    assert got == sorted(files, key=lambda f: f["path"])
+
+
+def test_ambiguous_src_and_flat_collision_raises(tmp_path: Path):
+    (tmp_path / "src" / "pkg").mkdir(parents=True)
+    (tmp_path / "src" / "pkg" / "x.py").write_text("a = 1\n")
+    (tmp_path / "pkg").mkdir()
+    (tmp_path / "pkg" / "x.py").write_text("b = 2\n")
+    try:
+        paths.read_tree(tmp_path)
+        raise AssertionError("expected ValueError on ambiguous tree")
+    except ValueError as e:
+        assert "ambiguous" in str(e)
+
+
+def test_content_round_trips_lf_exactly(tmp_path: Path):
+    original = [{"path": "flows/x.py", "content": "a = 1\nb = 2\n"}]
+    paths.write_tree(tmp_path, original)
+    # Written verbatim — no CRLF injection, even on Windows (newline="").
+    # Runnable Python lands under src/ (the on-disk library layout).
+    raw = (tmp_path / "src" / "flows" / "x.py").read_bytes()
+    assert b"\r\n" not in raw
+    assert raw == b"a = 1\nb = 2\n"
+    # And read_tree returns the same LF content under the flat overlay key.
+    assert paths.read_tree(tmp_path)[0]["content"] == "a = 1\nb = 2\n"
+
+
+def test_crlf_on_disk_is_normalised_to_lf_on_read(tmp_path: Path):
+    # Simulate a file that somehow has CRLF on disk (e.g. a Windows editor).
+    (tmp_path / "flows").mkdir()
+    (tmp_path / "flows" / "y.py").write_bytes(b"a = 1\r\nb = 2\r\n")
+    got = {f["path"]: f["content"] for f in paths.read_tree(tmp_path)}
+    assert got["flows/y.py"] == "a = 1\nb = 2\n"  # pushed content is LF-normalised
+
+
+def test_local_junk_is_excluded(tmp_path: Path):
+    paths.write_tree(tmp_path, [{"path": "flows/x.py", "content": "x=1\n"}])
+    (tmp_path / ".git").mkdir()
+    (tmp_path / ".git" / "config").write_text("[core]\n")
+    (tmp_path / "__pycache__").mkdir()
+    (tmp_path / "__pycache__" / "x.pyc").write_bytes(b"\x00")
+    (tmp_path / ".stml").mkdir()
+    (tmp_path / ".stml" / "app.json").write_text("{}")
+    (tmp_path / "src" / "flows" / "x.pyc").write_bytes(b"\x00")
+    keys = {f["path"] for f in paths.read_tree(tmp_path)}
+    assert keys == {"flows/x.py"}  # .git, __pycache__, .stml, *.pyc all dropped
+
+
+def test_key_to_native_and_back():
+    native = paths.key_to_native("flows/sub/x.py")
+    assert native == Path("flows") / "sub" / "x.py"
+    assert paths.to_posix_key(native) == "flows/sub/x.py"

stml_cli-0.1.2/stml_cli/paths.py

@@ -1,70 +0,0 @@
-"""Cross-platform overlay ↔ local-folder mapping (024 §OS & runtime support).
-
-The overlay keys the platform stores are always POSIX (``flows/x.py``). "Runs on
-Windows" is only real if the CLI:
-  1. maps a POSIX key to a NATIVE path when writing to disk, and back to a POSIX
-     key (never backslashes) when reading — via ``PurePosixPath`` on the wire,
-     ``Path`` on disk;
-  2. reads/writes UTF-8 and preserves ``\n`` exactly, so a pulled file survives
-     an untouched push byte-for-byte (no CRLF injection on Windows).
-
-These two functions are the whole contract; they are unit-tested in isolation so
-the Windows guarantee doesn't rest on a live round-trip.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path, PurePosixPath
-
-# Local-only artifacts that must never be pushed into the overlay.
-_EXCLUDE_DIRS = {
-    ".git", "__pycache__", ".venv", "venv", ".stml",
-    "node_modules", ".mypy_cache", ".ruff_cache", ".pytest_cache",
-}
-_EXCLUDE_NAMES = {".DS_Store"}
-_EXCLUDE_SUFFIXES = {".pyc", ".pyo"}
-
-
-def to_posix_key(rel: Path) -> str:
-    """A native relative path → the POSIX overlay key (forward slashes)."""
-    return PurePosixPath(*rel.parts).as_posix()
-
-
-def key_to_native(key: str) -> Path:
-    """A POSIX overlay key → a native relative Path for this OS."""
-    return Path(*PurePosixPath(key).parts)
-
-
-def read_tree(root: Path) -> list[dict]:
-    """Read a local folder into ``[{path, content}]`` with POSIX keys.
-
-    ``read_text`` (universal newlines) collapses any CRLF to ``\n``, so the
-    content pushed is always LF-normalised regardless of the author's OS.
-    """
-    out: list[dict] = []
-    for p in sorted(root.rglob("*")):
-        rel = p.relative_to(root)
-        if any(part in _EXCLUDE_DIRS for part in rel.parts):
-            continue
-        if p.name in _EXCLUDE_NAMES or p.suffix in _EXCLUDE_SUFFIXES:
-            continue
-        if not p.is_file():
-            continue
-        out.append({"path": to_posix_key(rel), "content": p.read_text(encoding="utf-8")})
-    return out
-
-
-def write_tree(root: Path, files: list[dict]) -> list[str]:
-    """Write ``[{path, content}]`` (POSIX keys) into a local folder.
-
-    ``newline=""`` disables newline translation so ``\n`` is written verbatim —
-    a pulled file is not silently rewritten to CRLF on Windows.
-    """
-    written: list[str] = []
-    for f in files:
-        key = f["path"]
-        dest = root / key_to_native(key)
-        dest.parent.mkdir(parents=True, exist_ok=True)
-        dest.write_text(f.get("content") or "", encoding="utf-8", newline="")
-        written.append(key)
-    return written

stml_cli-0.1.2/tests/test_paths.py

@@ -1,65 +0,0 @@
-"""Cross-platform overlay ↔ folder mapping (024 acceptance: CLI cross-platform).
-
-The Windows guarantee ("a pulled tree round-trips; overlay keys stay POSIX and
-content stays UTF-8/\\n") rests entirely on paths.read_tree / write_tree, so
-they are pinned here in isolation — no live backend, no OS assumptions.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from stml_cli import paths
-
-
-def test_keys_are_posix_even_for_nested_paths(tmp_path: Path):
-    files = [
-        {"path": "flows/greeting.py", "content": "print('hi')\n"},
-        {"path": "page/index.html", "content": "<h1>hi</h1>\n"},
-        {"path": "pyproject.toml", "content": "[project]\n"},
-    ]
-    paths.write_tree(tmp_path, files)
-    # Nested folders are created natively on disk...
-    assert (tmp_path / "flows" / "greeting.py").is_file()
-    # ...but reading back yields forward-slash POSIX keys, never backslashes.
-    keys = {f["path"] for f in paths.read_tree(tmp_path)}
-    assert keys == {"flows/greeting.py", "page/index.html", "pyproject.toml"}
-    assert not any("\\" in k for k in keys)
-
-
-def test_content_round_trips_lf_exactly(tmp_path: Path):
-    original = [{"path": "flows/x.py", "content": "a = 1\nb = 2\n"}]
-    paths.write_tree(tmp_path, original)
-    # Written verbatim — no CRLF injection, even on Windows (newline="").
-    raw = (tmp_path / "flows" / "x.py").read_bytes()
-    assert b"\r\n" not in raw
-    assert raw == b"a = 1\nb = 2\n"
-    # And read_tree returns the same LF content.
-    assert paths.read_tree(tmp_path)[0]["content"] == "a = 1\nb = 2\n"
-
-
-def test_crlf_on_disk_is_normalised_to_lf_on_read(tmp_path: Path):
-    # Simulate a file that somehow has CRLF on disk (e.g. a Windows editor).
-    (tmp_path / "flows").mkdir()
-    (tmp_path / "flows" / "y.py").write_bytes(b"a = 1\r\nb = 2\r\n")
-    got = {f["path"]: f["content"] for f in paths.read_tree(tmp_path)}
-    assert got["flows/y.py"] == "a = 1\nb = 2\n"  # pushed content is LF-normalised
-
-
-def test_local_junk_is_excluded(tmp_path: Path):
-    paths.write_tree(tmp_path, [{"path": "flows/x.py", "content": "x=1\n"}])
-    (tmp_path / ".git").mkdir()
-    (tmp_path / ".git" / "config").write_text("[core]\n")
-    (tmp_path / "__pycache__").mkdir()
-    (tmp_path / "__pycache__" / "x.pyc").write_bytes(b"\x00")
-    (tmp_path / ".stml").mkdir()
-    (tmp_path / ".stml" / "app.json").write_text("{}")
-    (tmp_path / "flows" / "x.pyc").write_bytes(b"\x00")
-    keys = {f["path"] for f in paths.read_tree(tmp_path)}
-    assert keys == {"flows/x.py"}  # .git, __pycache__, .stml, *.pyc all dropped
-
-
-def test_key_to_native_and_back():
-    native = paths.key_to_native("flows/sub/x.py")
-    assert native == Path("flows") / "sub" / "x.py"
-    assert paths.to_posix_key(native) == "flows/sub/x.py"