codepraxis 0.3.0__tar.gz → 0.3.2__tar.gz

{codepraxis-0.3.0 → codepraxis-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codepraxis
-Version: 0.3.0
+Version: 0.3.2
 Summary: Author and validate CodePraxis challenge packs.
 Project-URL: Documentation, https://docs.codepraxis.com/authoring
 Author: CodePraxis
@@ -35,6 +35,8 @@ codepraxis lint my-challenge                 # static checks, no execution
 codepraxis validate --local my-challenge     # run it, fast and advisory
 codepraxis --login
 codepraxis --publish my-challenge            # validates in the runner, then publishes
+codepraxis --list                            # list company questions
+codepraxis --edit 123 --open                 # update metadata/open a preview container
 ```
 
 ## What this is
@@ -153,7 +155,7 @@ codepraxis --install claude-plugin
 Writes a local plugin into `.codepraxis/claude-plugin/`, then tells you the two
 commands to enable it. You get:
 
-- **`/codepraxis:new`** — scaffold a pack from a description
+- **`/codepraxis:new`** — design, build, validate, publish and return a URL
 - **`/codepraxis:validate`** — validate and fix what fails, in a loop
 - **`pack-authoring` skill** — loads automatically when Claude touches a pack,
   so it already knows the `testCases` contract and the two-fixture rule
@@ -199,6 +201,21 @@ assigned to candidates immediately:
   publish into someone else's catalog.
 
 You'll be shown the company and asked to confirm before anything is created.
+When the platform can start a preview container, `--publish` prints that URL so
+you can inspect the question immediately.
+
+## Company catalog
+
+```bash
+codepraxis --list
+codepraxis --edit 123 --title "Debug webhook delivery" --status draft
+codepraxis --edit 123 --open
+```
+
+`--list` shows the questions owned by your API key's company, including drafts.
+`--edit` updates question metadata and returns a container URL for inspection.
+Code changes still go through the pack workflow: edit locally, validate, and
+publish a new version.
 
 ## Development
 

{codepraxis-0.3.0 → codepraxis-0.3.2}/README.md

@@ -10,6 +10,8 @@ codepraxis lint my-challenge                 # static checks, no execution
 codepraxis validate --local my-challenge     # run it, fast and advisory
 codepraxis --login
 codepraxis --publish my-challenge            # validates in the runner, then publishes
+codepraxis --list                            # list company questions
+codepraxis --edit 123 --open                 # update metadata/open a preview container
 ```
 
 ## What this is
@@ -128,7 +130,7 @@ codepraxis --install claude-plugin
 Writes a local plugin into `.codepraxis/claude-plugin/`, then tells you the two
 commands to enable it. You get:
 
-- **`/codepraxis:new`** — scaffold a pack from a description
+- **`/codepraxis:new`** — design, build, validate, publish and return a URL
 - **`/codepraxis:validate`** — validate and fix what fails, in a loop
 - **`pack-authoring` skill** — loads automatically when Claude touches a pack,
   so it already knows the `testCases` contract and the two-fixture rule
@@ -174,6 +176,21 @@ assigned to candidates immediately:
   publish into someone else's catalog.
 
 You'll be shown the company and asked to confirm before anything is created.
+When the platform can start a preview container, `--publish` prints that URL so
+you can inspect the question immediately.
+
+## Company catalog
+
+```bash
+codepraxis --list
+codepraxis --edit 123 --title "Debug webhook delivery" --status draft
+codepraxis --edit 123 --open
+```
+
+`--list` shows the questions owned by your API key's company, including drafts.
+`--edit` updates question metadata and returns a container URL for inspection.
+Code changes still go through the pack workflow: edit locally, validate, and
+publish a new version.
 
 ## Development
 

{codepraxis-0.3.0 → codepraxis-0.3.2}/src/codepraxis/__init__.py

@@ -1,3 +1,3 @@
 """Author and validate CodePraxis challenge packs."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"

{codepraxis-0.3.0 → codepraxis-0.3.2}/src/codepraxis/cli.py

@@ -12,6 +12,7 @@ import sys
 from pathlib import Path
 
 from . import __version__
+from .commands import catalog as catalog_command
 from .commands import example as example_command
 from .commands import lint as lint_command
 from .commands import login as login_command
@@ -59,6 +60,17 @@ def build_parser() -> argparse.ArgumentParser:
         metavar="PACK",
         help="Validate a pack in the runner, then publish it to your company.",
     )
+    actions.add_argument(
+        "--list",
+        action="store_true",
+        help="List questions that exist for your company.",
+    )
+    actions.add_argument(
+        "--edit",
+        type=int,
+        metavar="CHALLENGE_ID",
+        help="Edit question metadata and open its container preview.",
+    )
     actions.add_argument(
         "--install",
         choices=INSTALLABLES,
@@ -99,7 +111,27 @@ def build_parser() -> argparse.ArgumentParser:
         "--open",
         action="store_true",
         dest="open_browser",
-        help="With --example, open the container in your browser.",
+        help="With --example or --edit, open the container in your browser.",
+    )
+    parser.add_argument("--title", help="With --edit, update the question title.")
+    parser.add_argument("--description", help="With --edit, update the question description.")
+    parser.add_argument(
+        "--status",
+        choices=("draft", "published"),
+        help="With --edit, update whether the question is draft or published.",
+    )
+    parser.add_argument("--difficulty", type=int, choices=(1, 2, 3), help="With --edit, set difficulty.")
+    parser.add_argument("--max-time", type=int, help="With --edit, set time limit in minutes.")
+    parser.add_argument("--max-attempt", type=int, help="With --edit, set maximum attempts.")
+    parser.add_argument(
+        "--tech-stack",
+        help="With --edit, comma-separated technologies, for example 'Python,FastAPI'.",
+    )
+    parser.add_argument(
+        "--ai-enabled",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="With --edit, toggle AI assistance.",
     )
 
     subparsers = parser.add_subparsers(dest="command")
@@ -245,6 +277,22 @@ def _handle_new(args: argparse.Namespace) -> int:
     return 0
 
 
+def _edit_updates(args: argparse.Namespace) -> dict:
+    tech_stack = None
+    if args.tech_stack is not None:
+        tech_stack = [item.strip() for item in args.tech_stack.split(",") if item.strip()]
+    return {
+        "challenge_name": args.title,
+        "description": args.description,
+        "status": args.status,
+        "difficulty": args.difficulty,
+        "max_time": args.max_time,
+        "max_attempt": args.max_attempt,
+        "tech_stack": tech_stack,
+        "ai_enabled": args.ai_enabled,
+    }
+
+
 def _handle_install(target: str, force: bool) -> int:
     if target == "claude-plugin":
         result = installer.install(Path.cwd(), force=force)
@@ -269,6 +317,14 @@ def main(argv: list[str] | None = None) -> int:
                 live=args.live,
                 validation_run_id=args.validation_run_id,
             )
+        if args.list:
+            return catalog_command.list_questions(as_json=args.json)
+        if args.edit is not None:
+            return catalog_command.edit_question(
+                challenge_id=args.edit,
+                updates=_edit_updates(args),
+                open_browser=args.open_browser,
+            )
         if args.install:
             return _handle_install(args.install, args.force)
         if args.example:

codepraxis-0.3.2/src/codepraxis/commands/catalog.py

@@ -0,0 +1,81 @@
+"""Company challenge catalog commands for the public authoring API."""
+
+from __future__ import annotations
+
+import json
+import webbrowser
+from typing import Any
+
+from ..errors import PraxisError
+from ..execution.remote.client import ApiClient
+from ..execution.remote.config import RemoteConfig
+
+EXIT_OK = 0
+
+
+def list_questions(client: ApiClient | None = None, as_json: bool = False) -> int:
+    client = client or ApiClient(RemoteConfig.resolve())
+    payload = client.get("/challenges")
+    challenges = payload.get("challenges") or []
+
+    if as_json:
+        print(json.dumps({"challenges": challenges}, indent=2))
+        return EXIT_OK
+
+    if not challenges:
+        print("No questions found for this company.")
+        return EXIT_OK
+
+    for challenge in challenges:
+        _print_challenge(challenge)
+    return EXIT_OK
+
+
+def edit_question(
+    challenge_id: int,
+    updates: dict[str, Any] | None = None,
+    client: ApiClient | None = None,
+    open_browser: bool = False,
+) -> int:
+    client = client or ApiClient(RemoteConfig.resolve())
+    updates = {key: value for key, value in (updates or {}).items() if value is not None}
+
+    if updates:
+        payload = client.patch_json(f"/challenges/{challenge_id}", updates)
+        challenge = payload.get("challenge") or {}
+        updated_id = challenge.get("challenge_id") or challenge_id
+        updated_name = challenge.get("challenge_name") or ""
+        print(f"Updated question {updated_id}: {updated_name}")
+    else:
+        print(f"Opening question {challenge_id} in a container...")
+
+    session = client.post_json(f"/challenges/{challenge_id}/setup-codebase", {})
+    url = session.get("container_url")
+    if not url:
+        raise PraxisError("The platform prepared the question but returned no container URL.")
+
+    print(f"\n  {url}\n")
+    print(
+        "Use the container to inspect or adjust the question. "
+        "Publish a new pack version when code changes are ready."
+    )
+
+    if open_browser:
+        webbrowser.open(url)
+
+    return EXIT_OK
+
+
+def _print_challenge(challenge: dict[str, Any]) -> None:
+    challenge_id = challenge.get("challenge_id")
+    name = challenge.get("challenge_name") or "(untitled)"
+    status = challenge.get("status") or "unknown"
+    version = challenge.get("challenge_version_id")
+    updated = challenge.get("updated_at") or challenge.get("created_at")
+
+    line = f"{challenge_id}\t{name}\t{status}"
+    if version:
+        line += f"\tv{version}"
+    if updated:
+        line += f"\t{updated}"
+    print(line)

{codepraxis-0.3.0 → codepraxis-0.3.2}/src/codepraxis/commands/publish.py

@@ -84,11 +84,17 @@ def run(
 
     challenge_id = payload.get("challenge_id")
     version_id = payload.get("challenge_version_id")
+    container_url = payload.get("container_url")
+    preview_error = payload.get("preview_error")
     state = "published" if live else "draft"
 
     print(f"{pack.name} {state} for {company}")
     if challenge_id:
         print(f"  challenge {challenge_id}, version {version_id}")
+    if container_url:
+        print(f"  {container_url}")
+    elif preview_error:
+        print(f"  Preview container unavailable: {preview_error}")
     if not live:
         print("  Publish it to candidates from the dashboard when you are ready.")
     return EXIT_OK

{codepraxis-0.3.0 → codepraxis-0.3.2}/src/codepraxis/execution/remote/client.py

@@ -11,6 +11,8 @@ Endpoints used, served by ``api_authoring_controller`` under ``/api/public``
   ``POST /validation-runs``             -> submit a bundle, returns a run id
   ``GET  /validation-runs/{id}``        -> poll status + result
   ``POST /challenges``                  -> publish a validated pack
+  ``GET  /challenges``                  -> list company challenges
+  ``PATCH /challenges/{id}``            -> edit challenge metadata
 
 All four require an API key holding the ``challenges:write`` scope, except
 ``/me`` which only requires a valid key.
@@ -115,6 +117,14 @@ class ApiClient:
             content_type="application/json",
         )
 
+    def patch_json(self, path: str, payload: dict) -> dict[str, Any]:
+        return self.request(
+            "PATCH",
+            path,
+            body=json.dumps(payload).encode("utf-8"),
+            content_type="application/json",
+        )
+
     def post_bytes(self, path: str, blob: bytes) -> dict[str, Any]:
         return self.request("POST", path, body=blob, content_type="application/zip")
 

{codepraxis-0.3.0 → codepraxis-0.3.2}/src/codepraxis/plugin/installer.py

@@ -108,12 +108,16 @@ def describe(result: InstallResult) -> str:
             "",
             "Enable it in Claude Code:",
             "",
-            f"  /plugin marketplace add {relative}",
+            # The absolute path is deliberate. `/plugin marketplace add` reads a
+            # bare `foo/bar` as a GitHub owner/repo shorthand and tries to clone
+            # it, so a relative path here fails with "Repository not found". A
+            # leading slash cannot be parsed that way.
+            f"  /plugin marketplace add {result.root}",
             f"  /plugin install {PLUGIN_NAME}@{MARKETPLACE_NAME}",
             "",
             "Then:",
             "",
-            "  /codepraxis:new    scaffold a pack from a description",
+            "  /codepraxis:new         scaffold a pack from a description",
             "  /codepraxis:validate    validate a pack and fix what fails",
             "",
             "The pack-authoring skill loads automatically when Claude touches a pack.",

codepraxis-0.3.2/src/codepraxis/plugin/templates/commands/new.md

@@ -0,0 +1,42 @@
+---
+description: Design, build, validate, publish, and preview a CodePraxis question
+argument-hint: "<what the challenge should test>"
+allowed-tools: Bash(codepraxis validate:*), Bash(codepraxis --publish:*), Read, Write, Edit, Glob
+---
+
+Create and publish a new CodePraxis question for: **$ARGUMENTS**
+
+Build it in this order. Do not skip the design step, and do not claim the
+question is done until publish returns a URL.
+
+1. **Decide the question architecture.** Write down what skill this tests, the
+   expected task shape, the test cases you will need, and roughly how much code
+   the candidate should write. Prefer a realistic engineering task with one
+   obvious entry point, concrete sample input, and an output contract a test can
+   check automatically. Not a toy exercise, not a puzzle.
+
+2. **Implement the pack** under `challenges/<slug>/`:
+   - `metadata.json` — a unique snake_case `name`
+   - `backend.conf` — `BACKEND` and `LANGUAGE`
+   - `source/` — the minimal stub the grader calls, plus a `README.md` saying
+     what is broken and how to run it. No working implementation.
+   - `._tests/test_1.py` — the `testCases` class
+   - `._course_data/course_toc.json` and `feature.md` — the candidate brief
+   - `setup.sh` at the pack root if dependencies are needed
+
+3. **Write the reference solution** in `challenges/<slug>/../solution/` — a
+   sibling of the pack, never inside it.
+
+4. **Validate without asking the user to choose tiers.** Run
+   `codepraxis validate --local <slug>` and iterate until the solution passes
+   everything and the starter passes nothing. Then publish with
+   `codepraxis --publish <slug>`; the CLI runs the authoritative remote
+   validation before it publishes.
+
+5. **Publish and return the URL.** When `codepraxis --publish <slug>` succeeds,
+   copy the container URL from its output into your final answer so the user can
+   open the question and inspect it.
+
+Consult the `pack-authoring` skill for the `testCases` contract. The two
+mistakes worth checking before you finish: a starter that already passes, and a
+two-argument `__init__`.

codepraxis-0.3.2/tests/test_catalog.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from codepraxis.commands import catalog
+
+
+class FakeClient:
+    def __init__(self) -> None:
+        self.calls = []
+
+    def get(self, path: str) -> dict:
+        self.calls.append(("GET", path))
+        return {
+            "challenges": [
+                {
+                    "challenge_id": 7,
+                    "challenge_name": "Debug webhooks",
+                    "status": "draft",
+                    "challenge_version_id": 11,
+                }
+            ]
+        }
+
+    def patch_json(self, path: str, payload: dict) -> dict:
+        self.calls.append(("PATCH", path, payload))
+        return {"challenge": {"challenge_id": 7, "challenge_name": payload["challenge_name"]}}
+
+    def post_json(self, path: str, payload: dict) -> dict:
+        self.calls.append(("POST", path, payload))
+        return {"container_url": "https://container.example/?folder=/home/praxis/debug_webhooks"}
+
+
+def test_lists_company_questions(capsys):
+    client = FakeClient()
+
+    assert catalog.list_questions(client=client) == 0
+
+    assert client.calls == [("GET", "/challenges")]
+    output = capsys.readouterr().out
+    assert "Debug webhooks" in output
+    assert "draft" in output
+
+
+def test_edit_updates_metadata_and_prints_container_url(capsys):
+    client = FakeClient()
+
+    assert catalog.edit_question(
+        challenge_id=7,
+        updates={"challenge_name": "Debug queues", "description": None},
+        client=client,
+    ) == 0
+
+    assert client.calls == [
+        ("PATCH", "/challenges/7", {"challenge_name": "Debug queues"}),
+        ("POST", "/challenges/7/setup-codebase", {}),
+    ]
+    output = capsys.readouterr().out
+    assert "Updated question 7" in output
+    assert "https://container.example" in output
+
+
+def test_edit_can_open_without_metadata_changes(capsys):
+    client = FakeClient()
+
+    assert catalog.edit_question(challenge_id=7, updates={}, client=client) == 0
+
+    assert client.calls == [("POST", "/challenges/7/setup-codebase", {})]
+    assert "Opening question 7" in capsys.readouterr().out

{codepraxis-0.3.0 → codepraxis-0.3.2}/tests/test_publish.py

@@ -203,3 +203,27 @@ def test_live_publishes_immediately(tmp_path: Path):
     )
 
     assert client.posted[0][1]["status"] == "published"
+
+
+def test_prints_container_url_when_platform_returns_one(tmp_path: Path, capsys):
+    build_pack(tmp_path)
+
+    class PreviewClient(FakeClient):
+        def post_json(self, path: str, payload: dict) -> dict:
+            self.posted.append((path, payload))
+            return {
+                "challenge_id": 7,
+                "challenge_version_id": 9,
+                "container_url": "https://container.example/?folder=/home/praxis/demo",
+            }
+
+    publish.run(
+        root=tmp_path,
+        selector="demo",
+        reporter=NullReporter(),
+        assume_yes=True,
+        validation_run_id="vr_1",
+        client=PreviewClient(),
+    )
+
+    assert "https://container.example" in capsys.readouterr().out

{codepraxis-0.3.0 → codepraxis-0.3.2}/tests/test_validation_rules.py

@@ -219,3 +219,33 @@ class TestExampleCommand:
         monkeypatch.delenv("CODEPRAXIS_TOKEN", raising=False)
 
         assert RemoteConfig.resolve_public().token == ""
+
+
+class TestPluginInstructions:
+    """`/plugin marketplace add` reads a bare `foo/bar` as a GitHub repo.
+
+    A relative path there fails with "Repository not found", so the printed
+    command must be one that cannot be parsed as owner/repo.
+    """
+
+    def test_marketplace_command_uses_an_absolute_path(self, tmp_path, monkeypatch):
+        from codepraxis.plugin import installer
+
+        monkeypatch.chdir(tmp_path)
+        result = installer.install(tmp_path)
+        line = next(
+            text for text in installer.describe(result).splitlines() if "marketplace add" in text
+        )
+
+        path = line.split("marketplace add", 1)[1].strip()
+        assert path.startswith("/"), f"{path!r} would be read as a GitHub owner/repo"
+        assert Path(path).is_dir()
+
+    def test_the_marketplace_manifest_is_where_the_command_points(self, tmp_path, monkeypatch):
+        from codepraxis.plugin import installer
+
+        monkeypatch.chdir(tmp_path)
+        result = installer.install(tmp_path)
+
+        assert (result.root / ".claude-plugin" / "marketplace.json").is_file()
+        assert (result.root / "codepraxis" / ".claude-plugin" / "plugin.json").is_file()

codepraxis-0.3.0/src/codepraxis/plugin/templates/commands/new.md

@@ -1,32 +0,0 @@
----
-description: Scaffold a new CodePraxis challenge pack from a description
-argument-hint: "<what the challenge should test>"
-allowed-tools: Bash(codepraxis validate:*), Read, Write, Edit, Glob
----
-
-Create a new CodePraxis challenge pack for: **$ARGUMENTS**
-
-Build it in this order, and validate before you claim it is done.
-
-1. **Decide the shape.** A realistic engineering task with one obvious entry
-   point, concrete sample input, and an output contract a test can check
-   automatically. Not a toy exercise, not a puzzle.
-
-2. **Write the pack** under `challenges/<slug>/`:
-   - `metadata.json` — a unique snake_case `name`
-   - `backend.conf` — `BACKEND` and `LANGUAGE`
-   - `source/` — the minimal stub the grader calls, plus a `README.md` saying
-     what is broken and how to run it. No working implementation.
-   - `._tests/test_1.py` — the `testCases` class
-   - `._course_data/course_toc.json` and `feature.md` — the candidate brief
-   - `setup.sh` at the pack root if dependencies are needed
-
-3. **Write the reference solution** in `challenges/<slug>/../solution/` — a
-   sibling of the pack, never inside it.
-
-4. **Validate**: `codepraxis validate --local <slug>`. Iterate until the
-   solution passes everything and the starter passes nothing.
-
-Consult the `pack-authoring` skill for the `testCases` contract. The two
-mistakes worth checking before you finish: a starter that already passes, and a
-two-argument `__init__`.