sanka-cli 0.2.2__tar.gz → 0.2.4__tar.gz

{sanka_cli-0.2.2 → sanka_cli-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sanka-cli
-Version: 0.2.2
+Version: 0.2.4
 Summary: Sanka command-line interface and migration runtime
 Project-URL: Repository, https://github.com/sankaHQ/sanka
 Project-URL: Issues, https://github.com/sankaHQ/sanka/issues
@@ -149,3 +149,22 @@ The distribution license expression is
 `Apache-2.0 AND AGPL-3.0-only`. Both license texts and the historical hosted
 CLI notice ship in the wheel and source archive. File-level SPDX identifiers
 are authoritative.
+
+
+### Compact lifecycle output
+
+Use `--compact-dsl` instead of `--json` on `scan`, `plan`, `apply`, `test`,
+`verify`, and extension management commands when an agent needs a short result.
+The flags are mutually exclusive; `--json` retains its existing contract.
+Compact output starts with `sanka-compact/v1 <command> <outcome> <migration_state>`
+then emits one `key=JSON-value` per line. Strings use JSON escaping, including
+newlines and quotes. Failures, warnings, plan hashes, and limitations are retained.
+Legacy aliases are not repeated. With full artifacts available, generated file
+contents and route source code are replaced by explicit omission counts and file
+names. Read the returned artifact for those details; a compact summary is not a
+replacement for the full report. `data.plan_hash` becomes the `plan_hash` line;
+use that core hash for apply, not a nested extension hash.
+
+Keep the lifecycle: scan → plan → apply → test → verify. An applied scaffold with
+manual gaps is not complete. Test establishes generated scope; scenario verification
+checks HTTP and database parity within the supplied fixtures and cases.

{sanka_cli-0.2.2 → sanka_cli-0.2.4}/README.md

@@ -119,3 +119,22 @@ The distribution license expression is
 `Apache-2.0 AND AGPL-3.0-only`. Both license texts and the historical hosted
 CLI notice ship in the wheel and source archive. File-level SPDX identifiers
 are authoritative.
+
+
+### Compact lifecycle output
+
+Use `--compact-dsl` instead of `--json` on `scan`, `plan`, `apply`, `test`,
+`verify`, and extension management commands when an agent needs a short result.
+The flags are mutually exclusive; `--json` retains its existing contract.
+Compact output starts with `sanka-compact/v1 <command> <outcome> <migration_state>`
+then emits one `key=JSON-value` per line. Strings use JSON escaping, including
+newlines and quotes. Failures, warnings, plan hashes, and limitations are retained.
+Legacy aliases are not repeated. With full artifacts available, generated file
+contents and route source code are replaced by explicit omission counts and file
+names. Read the returned artifact for those details; a compact summary is not a
+replacement for the full report. `data.plan_hash` becomes the `plan_hash` line;
+use that core hash for apply, not a nested extension hash.
+
+Keep the lifecycle: scan → plan → apply → test → verify. An applied scaffold with
+manual gaps is not complete. Test establishes generated scope; scenario verification
+checks HTTP and database parity within the supplied fixtures and cases.

{sanka_cli-0.2.2 → sanka_cli-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sanka-cli"
-version = "0.2.2"
+version = "0.2.4"
 description = "Sanka command-line interface and migration runtime"
 readme = "README.md"
 requires-python = ">=3.12"

{sanka_cli-0.2.2 → sanka_cli-0.2.4}/src/sanka/cli/__init__.py

@@ -85,17 +85,21 @@ class _CliArgumentParser(argparse.ArgumentParser):
 
 def main(argv: list[str] | None = None) -> int:
     arguments = list(sys.argv[1:] if argv is None else argv)
-    json_errors = "--json" in arguments
+    json_errors = "--json" in arguments or "--compact-dsl" in arguments
     parser = _build_parser(json_errors=json_errors)
     try:
         args = parser.parse_args(arguments)
     except CliUsageError as error:
         command = arguments[0] if arguments and arguments[0] in SDK_COMMANDS else "sanka"
         return _print_cli_error(
-            argparse.Namespace(command=command, json=json_errors),
+            argparse.Namespace(
+                command=command, json=json_errors, compact_dsl="--compact-dsl" in arguments
+            ),
             error,
             exit_code=2,
         )
+    if getattr(args, "compact_dsl", False):
+        args.json = True
     if args.command is None:
         parser.print_help()
         return 0
@@ -173,12 +177,17 @@ def _json_result(
     return envelope
 
 
-def _print_json(payload: dict[str, Any]) -> None:
-    print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
+def _print_result(args: argparse.Namespace, payload: dict[str, Any]) -> None:
+    if getattr(args, "compact_dsl", False):
+        from sanka.cli._compact import render_compact
+
+        print(render_compact(payload))
+    else:
+        print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
 
 
 def _print_cli_error(args: argparse.Namespace, error: Exception, *, exit_code: int) -> int:
-    if getattr(args, "json", False):
+    if getattr(args, "json", False) or getattr(args, "compact_dsl", False):
         code = getattr(error, "code", None)
         details = getattr(error, "details", None)
         structured_error: dict[str, Any] = {
@@ -187,13 +196,14 @@ def _print_cli_error(args: argparse.Namespace, error: Exception, *, exit_code: i
         }
         if isinstance(details, dict) and details:
             structured_error["details"] = details
-        _print_json(
+        _print_result(
+            args,
             _json_result(
                 str(getattr(args, "command", "sanka") or "sanka"),
                 {"error": structured_error},
                 outcome="error",
                 migration_state="not_started" if exit_code == 2 else "failed",
-            )
+            ),
         )
     else:
         _terminal(args).failure(str(error))
@@ -221,9 +231,15 @@ def _build_parser(*, json_errors: bool = False) -> argparse.ArgumentParser:
 
     def presentation(sub: argparse.ArgumentParser, *, json_option: bool = True) -> None:
         if json_option:
-            sub.add_argument(
+            formats = sub.add_mutually_exclusive_group()
+            formats.add_argument(
                 "--json", action="store_true", help="print one sanka-cli/v1 JSON document"
             )
+            formats.add_argument(
+                "--compact-dsl",
+                action="store_true",
+                help="print a compact result; full generated code stays in artifacts",
+            )
         sub.add_argument("--no-color", action="store_true", help="disable ANSI color")
         detail = sub.add_mutually_exclusive_group()
         detail.add_argument("--quiet", action="store_true", help="print only outcome and errors")
@@ -414,7 +430,7 @@ def _build_parser(*, json_errors: bool = False) -> argparse.ArgumentParser:
         description=(
             "Check hashes, generated files, route coverage, and configured read-only HTTP "
             "comparisons. With --scenarios, replay a scenario file against the source "
-            "application and a candidate FastAPI app and diff status, body, declared "
+            "application and a candidate FastAPI or Flask app and diff status, body, declared "
             "headers, and database state; that mode needs no plan or generated manifest."
         ),
         epilog=(
@@ -436,6 +452,7 @@ def _build_parser(*, json_errors: bool = False) -> argparse.ArgumentParser:
         help="application repository root",
     )
     verify.add_argument("--to", help="select an application plan")
+    verify.add_argument("--settings", help="source Django settings module for scenario replay")
     verify.add_argument("--artifact-dir", default=DEFAULT_ARTIFACT_DIR)
     verify.add_argument("--output", default=None, help="generated FastAPI output directory")
     verify.add_argument(
@@ -667,11 +684,53 @@ def _extension_result(
     records: list[dict[str, Any]],
 ) -> int:
     data = {"operation": operation, "records": records}
-    if args.json:
-        _print_json(_json_result("extension", data, migration_state="not_started"))
-    else:
-        for record in records:
-            print(json.dumps(record, ensure_ascii=False, sort_keys=True))
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(args, _json_result("extension", data, migration_state="not_started"))
+        return 0
+
+    terminal = _terminal(args)
+    if operation == "list":
+        terminal.heading("Extensions")
+        terminal.table(
+            ("Extension", "Kind", "Version", "Status", "Marketplace"),
+            [
+                (
+                    str(record.get("id", "")),
+                    str(record.get("kind", "")),
+                    str(record.get("version", "")),
+                    ", ".join(map(str, record.get("status", []))),
+                    str(record.get("marketplace", "")),
+                )
+                for record in records
+            ],
+        )
+    elif operation == "marketplace_list":
+        terminal.heading("Marketplaces")
+        terminal.table(
+            ("Marketplace", "Source", "Commit", "Trusted"),
+            [
+                (
+                    str(record.get("name", "")),
+                    str(record.get("source", "")),
+                    str(record.get("resolved_commit") or "-")[:12],
+                    "yes" if record.get("trusted") else "no",
+                )
+                for record in records
+            ],
+        )
+    elif operation == "add":
+        record = records[0]
+        terminal.success(f"Installed {record['id']} {record['version']}")
+    elif operation == "remove":
+        terminal.success(f"Removed {records[0]['id']}")
+    elif operation == "marketplace_add":
+        terminal.success(f"Added marketplace {records[0]['name']}")
+    elif operation == "marketplace_upgrade":
+        terminal.success(
+            "Updated marketplace " + ", ".join(str(record["name"]) for record in records)
+        )
+    elif operation == "marketplace_remove":
+        terminal.success(f"Removed marketplace {records[0]['name']}")
     return 0
 
 
@@ -853,8 +912,9 @@ def _print_application_result(
     *,
     migration_state: str,
 ) -> int:
-    if args.json:
-        _print_json(
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(
+            args,
             _json_result(
                 command,
                 result.data,
@@ -862,7 +922,7 @@ def _print_application_result(
                 artifacts=list(result.artifacts),
                 limitations=list(result.limitations),
                 next_actions=list(result.next_actions),
-            )
+            ),
         )
     else:
         terminal = _terminal(args)
@@ -884,8 +944,9 @@ async def _cmd_plan(args: argparse.Namespace) -> int:
     engine = _engine(args.state)
     run_id = engine.create(spec)
     migration_plan = await engine.plan(run_id)
-    if args.json:
-        _print_json(
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(
+            args,
             _json_result(
                 "plan",
                 {
@@ -911,7 +972,7 @@ async def _cmd_plan(args: argparse.Namespace) -> int:
                         ]
                     )
                 ],
-            )
+            ),
         )
     else:
         _print_plan(run_id, migration_plan)
@@ -953,8 +1014,9 @@ async def _cmd_apply(args: argparse.Namespace) -> int:
     if run.plan_json is None:
         raise ExecutionError("no plan for this spec yet; run `sanka plan` first")
     await engine.apply(run_id, plan_hash=args.plan_hash)
-    if args.json:
-        _print_json(
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(
+            args,
             _json_result(
                 "apply",
                 {
@@ -975,7 +1037,7 @@ async def _cmd_apply(args: argparse.Namespace) -> int:
                         ]
                     )
                 ],
-            )
+            ),
         )
     else:
         print(f"run {run_id}: applied")
@@ -1011,8 +1073,9 @@ async def _cmd_verify(args: argparse.Namespace) -> int:
     engine = _engine(args.state)
     run_id = engine.create(spec)
     verify_report = await engine.verify(run_id)
-    if args.json:
-        _print_json(
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(
+            args,
             _json_result(
                 "verify",
                 {
@@ -1035,7 +1098,7 @@ async def _cmd_verify(args: argparse.Namespace) -> int:
                     "verified_within_scope" if verify_report.ok else "verification_failed"
                 ),
                 artifacts=[str(Path(args.state).resolve())],
-            )
+            ),
         )
     else:
         _print_verify(verify_report)

sanka_cli-0.2.4/src/sanka/cli/_compact.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+"""Model-facing presentation of the existing result, with JSON-escaped values."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def _summary(value: Any, *, path: tuple[str, ...] = (), artifacts: bool = False) -> Any:
+    if isinstance(value, dict):
+        if path in {("files",), ("extension", "files")} and artifacts:
+            return {"names": sorted(value), "omitted_file_contents": len(value)}
+        result = {}
+        for name, item in value.items():
+            if name == "extension" and isinstance(item, dict):
+                # Core lifecycle responses repeat extension fields; retain differing hashes.
+                item = {k: v for k, v in item.items() if k not in value or value[k] != v}
+                if not item:
+                    continue
+            if (
+                name == "source"
+                and {"classification", "method"} <= value.keys()
+                and isinstance(item, str)
+                and artifacts
+            ):
+                result["omitted_source_characters"] = len(item)
+            else:
+                result[name] = _summary(item, path=(*path, name), artifacts=artifacts)
+        return result
+    if isinstance(value, list):
+        return [_summary(item, path=(*path, "[]"), artifacts=artifacts) for item in value]
+    return value
+
+
+def render_compact(payload: dict[str, Any]) -> str:
+    """One header, then key=JSON lines. Never truncate failures, warnings or hashes."""
+    lines = [" ".join(str(payload[k]) for k in ("command", "outcome", "migration_state"))]
+    lines[0] = "sanka-compact/v1 " + lines[0]
+    data = _summary(payload["data"], artifacts=bool(payload.get("artifacts")))
+    for key, value in data.items():
+        # Escape even extension-defined keys so a newline cannot forge another record.
+        label = key if key.isidentifier() else json.dumps(key, ensure_ascii=False)
+        lines.append(label + "=" + json.dumps(value, ensure_ascii=False, separators=(",", ":")))
+    for key in ("artifacts", "limitations", "next_actions"):
+        if payload.get(key):
+            lines.append(
+                key + "=" + json.dumps(payload[key], ensure_ascii=False, separators=(",", ":"))
+            )
+    return "\n".join(lines)

{sanka_cli-0.2.2 → sanka_cli-0.2.4}/src/sanka/cli/_output.py

@@ -57,6 +57,24 @@ class TerminalOutput:
         if not self.quiet:
             print(self.style(value, "cyan"), file=self.stdout)
 
+    def table(self, headers: tuple[str, ...], rows: list[tuple[str, ...]]) -> None:
+        if self.quiet:
+            return
+        widths = [
+            max(len(header), *(len(row[index]) for row in rows))
+            for index, header in enumerate(headers)
+        ]
+        print(
+            "  ".join(header.ljust(width) for header, width in zip(headers, widths, strict=True)),
+            file=self.stdout,
+        )
+        print("  ".join("-" * width for width in widths), file=self.stdout)
+        for row in rows:
+            print(
+                "  ".join(value.ljust(width) for value, width in zip(row, widths, strict=True)),
+                file=self.stdout,
+            )
+
     def success(self, value: str) -> None:
         print(self.style(f"✓ OK  {value}", "green"), file=self.stdout)
 

{sanka_cli-0.2.2 → sanka_cli-0.2.4}/src/sanka/runtime/extensions/lifecycle.py

@@ -820,7 +820,7 @@ class ApplicationLifecycle:
         written, so the source fingerprint legitimately differs from any reviewed plan and
         a plan may not exist yet. The extension lock still has to match its recommendation
         exactly; only the plan, fingerprint, and artifact checks that guard apply and test
-        are skipped, because replay writes nothing into the project.
+        are skipped, because replay only writes verification artifacts in its artifact directory.
         """
         explicit_env_names = _canonical_environment_names(explicit_env_names)
         fingerprint = fingerprint_repository(self.project_root)
@@ -839,7 +839,6 @@ class ApplicationLifecycle:
         if result.outcome != "success":
             self._raise_failure(result)
         data = dict(result.data)
-        data["extension"] = result.data
         return ExtensionResult(
             outcome="success",
             data=data,

{sanka_cli-0.2.2 → sanka_cli-0.2.4}/src/sanka/runtime/extensions/store.py

@@ -529,6 +529,13 @@ def _create_venv(
     )
 
 
+def _venv_launcher_names() -> tuple[str, ...]:
+    names = ("python", "python3", f"python{sys.version_info.major}.{sys.version_info.minor}")
+    if sys.version_info[:2] == (3, 14) and sys.getfilesystemencoding() == "utf-8":
+        names += ("𝜋thon",)
+    return names
+
+
 def _normalize_venv_launchers(environment_descriptor: int) -> None:
     if os.name == "nt":
         return
@@ -543,10 +550,9 @@ def _normalize_venv_launchers(environment_descriptor: int) -> None:
                 )
             os.unlink("lib64", dir_fd=environment_descriptor)
     interpreter = Path(sys.executable).resolve()
-    names = ("python", "python3", f"python{sys.version_info.major}.{sys.version_info.minor}")
     with _directory_at(environment_descriptor, "bin", Path("bin")) as bin_descriptor:
         assert bin_descriptor is not None
-        for name in names:
+        for name in _venv_launcher_names():
             with suppress(FileNotFoundError):
                 status = os.stat(name, dir_fd=bin_descriptor, follow_symlinks=False)
                 if not (stat.S_ISLNK(status.st_mode) or stat.S_ISREG(status.st_mode)):
@@ -2830,24 +2836,29 @@ class ExtensionStore:
                 missing_ok=True,
             ) as existing:
                 if existing is not None:
-                    digest = content_hash(
-                        _tree_records(
-                            existing,
-                            error_code="SANKA_EXTENSION_PATH",
-                            subject="Extension environment",
-                            allowed_symlinks=self._environment_symlinks(),
-                        )
-                    )
-                    if digest == expected_digest:
-                        try:
-                            self._verify_environment_artifacts(
-                                root, executable, wheels, providers=providers
+                    try:
+                        digest = content_hash(
+                            _tree_records(
+                                existing,
+                                error_code="SANKA_EXTENSION_PATH",
+                                subject="Extension environment",
+                                allowed_symlinks=self._environment_symlinks(),
                             )
-                        except ExtensionError as error:
-                            if error.code != "SANKA_EXTENSION_HASH_MISMATCH":
-                                raise
-                        else:
-                            return root
+                        )
+                    except ExtensionError as error:
+                        if error.code != "SANKA_EXTENSION_PATH" or expected_digest is not None:
+                            raise
+                    else:
+                        if digest == expected_digest:
+                            try:
+                                self._verify_environment_artifacts(
+                                    root, executable, wheels, providers=providers
+                                )
+                            except ExtensionError as error:
+                                if error.code != "SANKA_EXTENSION_HASH_MISMATCH":
+                                    raise
+                            else:
+                                return root
                     replace_existing = True
             if replace_existing:
                 shutil.rmtree(environment_name, dir_fd=environments)
@@ -3212,11 +3223,7 @@ class ExtensionStore:
     def _environment_symlinks() -> dict[str, Path]:
         interpreter = Path(sys.executable).resolve()
         return dict.fromkeys(
-            (
-                "bin/python",
-                "bin/python3",
-                f"bin/python{sys.version_info.major}.{sys.version_info.minor}",
-            ),
+            (f"bin/{name}" for name in _venv_launcher_names()),
             interpreter,
         )
 

{sanka_cli-0.2.2 → sanka_cli-0.2.4}/src/sanka_cli/__init__.py

@@ -1,4 +1,4 @@
 # SPDX-License-Identifier: Apache-2.0
 __all__ = ["__version__"]
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{sanka_cli-0.2.2 → sanka_cli-0.2.4}/src/sanka_cli/client.py

@@ -87,16 +87,43 @@ class SankaApiClient:
         path: str,
         *,
         params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        max_bytes: int | None = None,
     ) -> tuple[bytes, dict[str, str]]:
         """Fetch a non-JSON body (currently only the Custom Code bundle download).
 
         Returns headers alongside the payload so the caller can verify the digest the
         server reports without a second request.
         """
+        request_headers = self._headers()
+        request_headers.update(headers or {})
+        if max_bytes is not None:
+            with self.client.stream(
+                method.upper(),
+                path,
+                headers=request_headers,
+                params=params,
+            ) as response:
+                content = bytearray()
+                for chunk in response.iter_bytes(chunk_size=65536):
+                    if len(content) + len(chunk) > max_bytes:
+                        raise APIError(
+                            status_code=413, message="API artifact exceeds its size limit"
+                        )
+                    content.extend(chunk)
+                if response.status_code >= 400:
+                    self._raise_for_response(
+                        httpx.Response(
+                            response.status_code,
+                            content=bytes(content),
+                            headers=response.headers,
+                        )
+                    )
+                return bytes(content), dict(response.headers)
         response = self.client.request(
             method.upper(),
             path,
-            headers=self._headers(),
+            headers=request_headers,
             params=params,
         )
         if response.status_code >= 400: