codepraxis 0.3.1__tar.gz → 0.3.3__tar.gz

{codepraxis-0.3.1 → codepraxis-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codepraxis
-Version: 0.3.1
+Version: 0.3.3
 Summary: Author and validate CodePraxis challenge packs.
 Project-URL: Documentation, https://docs.codepraxis.com/authoring
 Author: CodePraxis
@@ -35,6 +35,9 @@ 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
+codepraxis --publish my-challenge --challenge-id 123   # publish an edit, not a duplicate
 ```
 
 ## What this is
@@ -153,7 +156,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 +202,46 @@ 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.
+
+### Publishing an edit
+
+Changing the *content* of a question means re-publishing the pack. Pass the
+question's id, or you get a second copy:
+
+```bash
+codepraxis --publish my-challenge --challenge-id 123
+```
+
+With `--challenge-id` the platform adds a new version to that question and
+keeps its id, assignments and history. Without it, publish always creates a
+new question — which is the right behaviour the first time and a duplicate
+every time after.
+
+### Deleting
+
+```bash
+codepraxis --delete 123
+```
+
+Asks first, and the platform refuses outright once the question has been
+assigned to anyone — deleting it then would orphan attempts and reports that
+candidates and reviewers still depend on. To take an assigned question out of
+circulation, set it back to draft with `--edit 123 --status draft`.
+Code changes still go through the pack workflow: edit locally, validate, and
+publish a new version.
 
 ## Development
 

{codepraxis-0.3.1 → codepraxis-0.3.3}/README.md

@@ -10,6 +10,9 @@ 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
+codepraxis --publish my-challenge --challenge-id 123   # publish an edit, not a duplicate
 ```
 
 ## What this is
@@ -128,7 +131,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 +177,46 @@ 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.
+
+### Publishing an edit
+
+Changing the *content* of a question means re-publishing the pack. Pass the
+question's id, or you get a second copy:
+
+```bash
+codepraxis --publish my-challenge --challenge-id 123
+```
+
+With `--challenge-id` the platform adds a new version to that question and
+keeps its id, assignments and history. Without it, publish always creates a
+new question — which is the right behaviour the first time and a duplicate
+every time after.
+
+### Deleting
+
+```bash
+codepraxis --delete 123
+```
+
+Asks first, and the platform refuses outright once the question has been
+assigned to anyone — deleting it then would orphan attempts and reports that
+candidates and reviewers still depend on. To take an assigned question out of
+circulation, set it back to draft with `--edit 123 --status draft`.
+Code changes still go through the pack workflow: edit locally, validate, and
+publish a new version.
 
 ## Development
 

{codepraxis-0.3.1 → codepraxis-0.3.3}/src/codepraxis/__init__.py

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

{codepraxis-0.3.1 → codepraxis-0.3.3}/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,23 @@ 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(
+        "--delete",
+        type=int,
+        metavar="CHALLENGE_ID",
+        help="Delete a question your company owns. Refused once it has been assigned.",
+    )
     actions.add_argument(
         "--install",
         choices=INSTALLABLES,
@@ -84,6 +102,14 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="With --publish, publish straight to candidates instead of as a draft.",
     )
+    parser.add_argument(
+        "--challenge-id",
+        type=int,
+        help=(
+            "With --publish, publish a new version of this existing question "
+            "instead of creating another one. Get the id from --list."
+        ),
+    )
     parser.add_argument(
         "--validation-run-id",
         help="With --publish, reuse a passing validation run instead of running a new one.",
@@ -99,7 +125,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 +291,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)
@@ -268,7 +330,18 @@ def main(argv: list[str] | None = None) -> int:
                 assume_yes=args.yes,
                 live=args.live,
                 validation_run_id=args.validation_run_id,
+                challenge_id=args.challenge_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.delete is not None:
+            return catalog_command.delete_question(args.delete, assume_yes=args.yes)
         if args.install:
             return _handle_install(args.install, args.force)
         if args.example:

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

@@ -0,0 +1,114 @@
+"""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
+EXIT_ABORTED = 2
+
+
+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)
+
+
+def delete_question(
+    challenge_id: int,
+    client: ApiClient | None = None,
+    assume_yes: bool = False,
+) -> int:
+    """Delete a question the company owns.
+
+    Confirmed by default: unlike a draft, this is not recoverable from the
+    dashboard. The platform refuses outright once the question has been assigned
+    to anyone, so the destructive case this guards is an unassigned question the
+    author still wanted.
+    """
+    import sys
+
+    client = client or ApiClient(RemoteConfig.resolve())
+
+    if not assume_yes:
+        if not sys.stdin.isatty():
+            raise PraxisError(
+                "Deleting needs confirmation, but stdin is not a terminal. Pass --yes."
+            )
+        print(f"Permanently delete question {challenge_id}? This cannot be undone.")
+        if input("Continue? [y/N] ").strip().lower() not in {"y", "yes"}:
+            print("Aborted.", file=sys.stderr)
+            return EXIT_ABORTED
+
+    payload = client.delete(f"/challenges/{challenge_id}")
+    removed = payload.get("versions_removed", 0)
+    print(f"Deleted question {challenge_id} ({removed} version(s) removed).")
+    return EXIT_OK

{codepraxis-0.3.1 → codepraxis-0.3.3}/src/codepraxis/commands/publish.py

@@ -40,6 +40,7 @@ def run(
     assume_yes: bool = False,
     live: bool = False,
     validation_run_id: str | None = None,
+    challenge_id: int | None = None,
     client: ApiClient | None = None,
 ) -> int:
     if not selector:
@@ -68,27 +69,40 @@ def run(
         run_id = _validate(pack, client, reporter)
 
     company = _company_name(client, config)
-    if not _confirm(pack.name, company, live, assume_yes):
+    if not _confirm(pack.name, company, live, assume_yes, challenge_id):
         print("Aborted.", file=sys.stderr)
         return EXIT_ABORTED
 
-    payload = client.post_json(
-        "/challenges",
-        {
-            # No company_id: the server derives ownership from the API key.
-            "name": pack.name,
-            "validation_run_id": run_id,
-            "status": "published" if live else "draft",
-        },
-    )
+    body = {
+        # No company_id: the server derives ownership from the API key.
+        "name": pack.name,
+        "validation_run_id": run_id,
+        "status": "published" if live else "draft",
+    }
+    # With an id, this publishes a new version of an existing question. Without
+    # one the platform creates a new question — which is why editing a pack and
+    # re-publishing used to leave a duplicate behind.
+    if challenge_id is not None:
+        body["challenge_id"] = challenge_id
+
+    payload = client.post_json("/challenges", body)
 
     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"
+    created = payload.get("created", True)
 
-    print(f"{pack.name} {state} for {company}")
+    verb = "published" if created else "updated"
+    print(f"{pack.name} {verb} for {company} ({state})")
     if challenge_id:
-        print(f"  challenge {challenge_id}, version {version_id}")
+        label = "challenge" if created else "challenge (new version of)"
+        print(f"  {label} {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
@@ -123,7 +137,7 @@ def _company_name(client: ApiClient, config: RemoteConfig | None) -> str:
     return company.get("name") or cached or "your company"
 
 
-def _confirm(pack_name: str, company: str, live: bool, assume_yes: bool) -> bool:
+def _confirm(pack_name: str, company: str, live: bool, assume_yes: bool, challenge_id: int | None = None) -> bool:
     if assume_yes:
         return True
     if not sys.stdin.isatty():
@@ -132,5 +146,6 @@ def _confirm(pack_name: str, company: str, live: bool, assume_yes: bool) -> bool
             "Pass --yes to publish non-interactively (CI)."
         )
     visibility = "LIVE to candidates" if live else "as a draft"
-    print(f"\nAbout to publish {pack_name} to {company}, {visibility}.")
+    target = f"as a new version of question {challenge_id}" if challenge_id else "as a new question"
+    print(f"\nAbout to publish {pack_name} to {company} {target}, {visibility}.")
     return input("Continue? [y/N] ").strip().lower() in {"y", "yes"}

{codepraxis-0.3.1 → codepraxis-0.3.3}/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,17 @@ 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 delete(self, path: str) -> dict[str, Any]:
+        return self.request("DELETE", path)
+
     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.3/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.3/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.1 → codepraxis-0.3.3}/tests/test_publish.py

@@ -203,3 +203,117 @@ 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
+
+
+class TestRepublishingAnEdit:
+    """Editing a pack and publishing again must update, not duplicate.
+
+    Without a challenge_id the platform creates a new question every time, which
+    is how a typo fix used to leave two copies in the catalog.
+    """
+
+    def test_challenge_id_is_sent_when_given(self, tmp_path):
+        build_pack(tmp_path)
+        client = FakeClient()
+
+        publish.run(
+            root=tmp_path,
+            selector="demo",
+            reporter=NullReporter(),
+            assume_yes=True,
+            validation_run_id="vr_1",
+            challenge_id=64,
+            client=client,
+        )
+
+        assert client.posted[0][1]["challenge_id"] == 64
+
+    def test_no_challenge_id_means_create(self, tmp_path):
+        build_pack(tmp_path)
+        client = FakeClient()
+
+        publish.run(
+            root=tmp_path,
+            selector="demo",
+            reporter=NullReporter(),
+            assume_yes=True,
+            validation_run_id="vr_1",
+            client=client,
+        )
+
+        assert "challenge_id" not in client.posted[0][1]
+
+    def test_output_says_updated_when_the_platform_reused_a_question(self, tmp_path, capsys):
+        build_pack(tmp_path)
+        client = FakeClient()
+        client.post_json = lambda path, payload: {
+            "challenge_id": 64,
+            "challenge_version_id": 91,
+            "created": False,
+        }
+
+        publish.run(
+            root=tmp_path,
+            selector="demo",
+            reporter=NullReporter(),
+            assume_yes=True,
+            validation_run_id="vr_1",
+            challenge_id=64,
+            client=client,
+        )
+
+        output = capsys.readouterr().out
+        assert "updated" in output
+        assert "published for" not in output
+
+
+class TestDelete:
+    class Client:
+        def __init__(self, payload=None):
+            self.deleted = []
+            self.payload = payload or {"challenge_id": 7, "versions_removed": 2}
+
+        def delete(self, path):
+            self.deleted.append(path)
+            return self.payload
+
+    def test_deletes_after_confirmation_is_waived(self, capsys):
+        from codepraxis.commands import catalog
+
+        client = self.Client()
+        assert catalog.delete_question(7, client=client, assume_yes=True) == 0
+        assert client.deleted == ["/challenges/7"]
+        assert "Deleted question 7" in capsys.readouterr().out
+
+    def test_refuses_without_a_terminal_and_without_yes(self):
+        from codepraxis.commands import catalog
+        from codepraxis.errors import PraxisError
+
+        client = self.Client()
+        with pytest.raises(PraxisError, match="not a terminal"):
+            catalog.delete_question(7, client=client)
+        assert client.deleted == []

codepraxis-0.3.1/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__`.