podojo-cli 1.3.0__tar.gz → 1.5.0__tar.gz

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to the Podojo CLI will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com),
 and this project adheres to [Semantic Versioning](https://semver.org).
 
+## [1.5.0] - 2026-07-02
+
+### Added
+- New `aiinterviews` command group to manage AI interview (voice-interviewer) study configs: `example`, `validate`, `create`, `get`, `update`, `delete`, and `list`. Participant Preview/Live URLs are built from the new `ai_interviews_url` config value (`~/.podojo.toml` key `ai_interviews_url`, env `PODOJO_AI_INTERVIEWS_URL`, or the default frontend URL).
+
+## [1.4.0] - 2026-05-31
+
+### Added
+- Support `image_file:` in usertest step config — a local image path that is uploaded to Podojo-hosted storage on `create`/`update` and replaced with the hosted URL. Relative paths resolve against the YAML file's location. Externally-hosted `image:` URLs continue to work.
+
 ## [1.3.0] - 2026-05-25
 
 ### Removed

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/CLAUDE.md

@@ -77,6 +77,4 @@ api_key = "your-api-key"
 
 ## Git Commits
 
-- Do NOT add "Co-Authored-By: Claude" trailers to commit messages
-- Keep commit messages concise and focused on the "why"
 - Commit directly to `main` — this is a solo project, no branching needed

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: podojo-cli
-Version: 1.3.0
+Version: 1.5.0
 Summary: CLI for the Podojo user research platform
 Project-URL: Homepage, https://github.com/podojo/cli-podojo
 Project-URL: Source, https://github.com/podojo/cli-podojo

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "podojo-cli"
-version = "1.3.0"
+version = "1.5.0"
 description = "CLI for the Podojo user research platform"
 readme = "README.md"
 license = "MIT"

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/src/podojo_cli/client.py

@@ -132,6 +132,30 @@ class PodojoClient:
         r.raise_for_status()
         return r.json()
 
+    IMAGE_CONTENT_TYPES = {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".webp": "image/webp",
+        ".gif": "image/gif",
+    }
+
+    def upload_usertest_image(self, file_path: Path) -> dict:
+        content_type = self.IMAGE_CONTENT_TYPES.get(file_path.suffix.lower())
+        if content_type is None:
+            raise ValueError(
+                f"Unsupported image type '{file_path.suffix}'. Allowed: PNG, JPEG, WebP, GIF."
+            )
+        with file_path.open("rb") as f:
+            r = httpx.post(
+                f"{self.base_url}/usertests/images",
+                files={"file": (file_path.name, f, content_type)},
+                headers=self._headers(),
+                timeout=httpx.Timeout(None),
+            )
+        r.raise_for_status()
+        return r.json()
+
     def create_usertest(self, data: dict) -> dict:
         r = httpx.post(
             f"{self.base_url}/usertests",
@@ -157,3 +181,46 @@ class PodojoClient:
         )
         r.raise_for_status()
         return r.json()
+
+    def list_ai_interviews(self, skip: int = 0, limit: int = 50) -> dict:
+        r = httpx.get(
+            f"{self.base_url}/ai-interviews",
+            params={"skip": skip, "limit": limit},
+            headers=self._headers(),
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def get_ai_interview(self, interview_id: str) -> dict:
+        r = httpx.get(
+            f"{self.base_url}/ai-interviews/{interview_id}",
+            headers=self._headers(),
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def create_ai_interview(self, data: dict) -> dict:
+        r = httpx.post(
+            f"{self.base_url}/ai-interviews",
+            json=data,
+            headers=self._headers(),
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def update_ai_interview(self, interview_id: str, data: dict) -> dict:
+        r = httpx.put(
+            f"{self.base_url}/ai-interviews/{interview_id}",
+            json=data,
+            headers=self._headers(),
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def delete_ai_interview(self, interview_id: str) -> dict:
+        r = httpx.delete(
+            f"{self.base_url}/ai-interviews/{interview_id}",
+            headers=self._headers(),
+        )
+        r.raise_for_status()
+        return r.json()

podojo_cli-1.5.0/src/podojo_cli/commands/aiinterviews.py

@@ -0,0 +1,323 @@
+from pathlib import Path
+
+import httpx
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from ..client import PodojoClient
+from ..config import load_config
+
+app = typer.Typer(help="Manage AI voice interviews")
+console = Console()
+
+REQUIRED_FIELDS = ["interview_id", "title", "questions", "closing_message"]
+REQUIRED_QUESTION_FIELDS = ["text"]
+
+EXAMPLE_YAML = """\
+# Podojo AI Interview Configuration
+#
+# One file = one study. This YAML is the source of truth: editing it edits the
+# interview. The AI interviewer conducts a voice conversation built from the
+# questions below.
+#
+# Required fields: interview_id, title, questions, closing_message
+# Optional fields: language (default en-US), project_name, overview,
+#                  decision, live
+#
+# Each question:
+#   text            (required) the main question, asked verbatim-ish in order
+#   section         (optional) researcher-facing grouping label
+#   max_follow_ups  (optional, default 2) adaptive follow-up budget
+#   probe_for       (optional) what a concrete answer must cover — drives follow-ups
+
+interview_id: checkout-experience-v1
+title: Checkout Experience Research
+language: en-US
+
+# Optional: link interview to a project
+project_name: checkout-redesign-q1
+
+# Optional: research context that grounds the interviewer's follow-ups
+overview: |
+  We're redesigning the checkout flow of our online store. This study targets
+  recent customers to understand how they decide what to buy, what slows them
+  down during checkout, and what would make them complete a purchase.
+
+  Key questions:
+  - How do customers move from browsing to buying?
+  - What friction shows up during checkout (payment, shipping, account creation)?
+  - What would make customers abandon a purchase at the last step?
+
+# Optional: the decision this research informs
+decision: >
+  Redesign the checkout flow to reduce cart abandonment.
+
+# Optional: set interview live (default: false)
+# live: true
+
+questions:
+  - section: Shopping Habits
+    text: >
+      Think about the last time you bought something online. Walk me through
+      how you went from finding the product to completing the purchase.
+    max_follow_ups: 3
+    probe_for: >
+      Specific steps taken (search, comparison, reviews), devices used, and
+      anything that slowed them down or almost made them give up.
+
+  - section: Checkout Friction
+    text: >
+      Think about a time you abandoned an online purchase at checkout.
+      What made you stop?
+    max_follow_ups: 3
+    probe_for: >
+      Unexpected costs, forced account creation, missing payment options,
+      delivery times. Ask what would have changed their mind.
+
+  - section: Checkout Friction
+    text: >
+      When you reach a checkout page, what's the first thing you look at
+      before entering your details?
+    max_follow_ups: 1
+
+closing_message: >
+  Thank you for sharing your experience! Your feedback is incredibly valuable
+  and will help us improve the shopping experience.
+"""
+
+
+def validate_ai_interview_data(data: dict) -> list[str]:
+    """Validate AI interview YAML data, return list of error strings."""
+    errors = []
+    for field in REQUIRED_FIELDS:
+        if field not in data or data[field] is None:
+            errors.append(f"Missing required field: '{field}'")
+
+    questions = data.get("questions")
+    if questions is not None:
+        if not isinstance(questions, list):
+            errors.append("'questions' must be a list")
+        elif len(questions) == 0:
+            errors.append("'questions' must contain at least one question")
+        else:
+            for i, question in enumerate(questions, 1):
+                if not isinstance(question, dict):
+                    errors.append(f"Question {i}: must be a mapping with 'text'")
+                    continue
+                for field in REQUIRED_QUESTION_FIELDS:
+                    if field not in question:
+                        errors.append(f"Question {i}: missing required field '{field}'")
+                max_follow_ups = question.get("max_follow_ups")
+                if max_follow_ups is not None and (
+                    isinstance(max_follow_ups, bool)
+                    or not isinstance(max_follow_ups, int)
+                    or max_follow_ups < 0
+                ):
+                    errors.append(
+                        f"Question {i}: 'max_follow_ups' must be an integer >= 0, got '{max_follow_ups}'"
+                    )
+    return errors
+
+
+def _load_yaml(path: Path) -> dict:
+    """Load and parse YAML file."""
+    if not path.exists():
+        console.print(f"[red]Error:[/red] File not found: {path}")
+        raise typer.Exit(1)
+    try:
+        with open(path) as f:
+            data = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        console.print(f"[red]Error:[/red] Invalid YAML syntax:\n{e}")
+        raise typer.Exit(1)
+    if not isinstance(data, dict):
+        console.print("[red]Error:[/red] YAML file must contain a mapping (key-value pairs)")
+        raise typer.Exit(1)
+    return data
+
+
+def _format_api_error(e: httpx.HTTPStatusError) -> str:
+    """Format API error into actionable message."""
+    try:
+        detail = e.response.json().get("detail", "")
+        if isinstance(detail, list):
+            messages = []
+            for err in detail:
+                loc = " -> ".join(str(x) for x in err.get("loc", []))
+                messages.append(f"  {loc}: {err.get('msg', '')}")
+            return "Validation errors:\n" + "\n".join(messages)
+        return str(detail)
+    except Exception:
+        return e.response.text
+
+
+def _ai_interviews_url() -> str:
+    return load_config()["ai_interviews_url"].rstrip("/")
+
+
+@app.command("list")
+def list_ai_interviews(
+    skip: int = typer.Option(0, help="Number of AI interviews to skip"),
+    limit: int = typer.Option(50, help="Max AI interviews to return"),
+):
+    """List all AI interviews."""
+    client = PodojoClient()
+    try:
+        result = client.list_ai_interviews(skip=skip, limit=limit)
+    except httpx.HTTPStatusError as e:
+        console.print(f"[red]Error:[/red] {_format_api_error(e)}")
+        raise typer.Exit(1)
+
+    ai_interviews = result.get("ai_interviews", [])
+    if not ai_interviews:
+        console.print("No AI interviews found.")
+        return
+
+    table = Table(title="AI Interviews")
+    table.add_column("Interview ID")
+    table.add_column("Title")
+    table.add_column("Language")
+    table.add_column("Questions", justify="right")
+    table.add_column("Live")
+    table.add_column("Last Updated")
+
+    for s in ai_interviews:
+        live = "[green]Yes[/green]" if s.get("live") else "[dim]No[/dim]"
+        table.add_row(
+            s.get("interview_id", ""),
+            s.get("title", ""),
+            s.get("language", ""),
+            str(s.get("question_count", "")),
+            live,
+            s.get("last_updated", ""),
+        )
+
+    console.print(table)
+
+
+@app.command("get")
+def get_ai_interview(
+    interview_id: str = typer.Argument(help="AI interview ID to retrieve"),
+):
+    """Get an AI interview and output as YAML."""
+    client = PodojoClient()
+    try:
+        interview = client.get_ai_interview(interview_id)
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 404:
+            console.print(f"[red]Error:[/red] AI interview '{interview_id}' not found")
+        else:
+            console.print(f"[red]Error:[/red] {_format_api_error(e)}")
+        raise typer.Exit(1)
+
+    # Remove server-managed fields for a clean editable output
+    group = interview.pop("group", "")
+    for key in ("id", "created_at", "created_by", "last_updated"):
+        interview.pop(key, None)
+
+    console.print(yaml.dump(interview, default_flow_style=False, sort_keys=False, allow_unicode=True))
+    if group:
+        base = _ai_interviews_url()
+        console.print(f"Preview: {base}/preview/{group}/{interview_id}")
+        console.print(f"Live:    {base}/{group}/{interview_id}")
+
+
+@app.command("create")
+def create_ai_interview(
+    from_file: Path = typer.Option(..., "--from-file", "-f", help="YAML file with AI interview config"),
+):
+    """Create a new AI interview from a YAML file."""
+    data = _load_yaml(from_file)
+
+    errors = validate_ai_interview_data(data)
+    if errors:
+        console.print("[red]Validation errors:[/red]")
+        for err in errors:
+            console.print(f"  {err}")
+        raise typer.Exit(1)
+
+    client = PodojoClient()
+    try:
+        result = client.create_ai_interview(data)
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 409:
+            console.print(f"[red]Error:[/red] AI interview '{data.get('interview_id')}' already exists")
+        else:
+            console.print(f"[red]Error:[/red] {_format_api_error(e)}")
+        raise typer.Exit(1)
+
+    interview_id = result.get("interview_id", "")
+    group = result.get("group", "")
+    console.print(f"[green]Created AI interview:[/green] {interview_id}")
+    if group:
+        base = _ai_interviews_url()
+        console.print(f"  Preview: {base}/preview/{group}/{interview_id}")
+        console.print(f"  Live:    {base}/{group}/{interview_id}")
+
+
+@app.command("update")
+def update_ai_interview(
+    interview_id: str = typer.Argument(help="AI interview ID to update"),
+    from_file: Path = typer.Option(..., "--from-file", "-f", help="YAML file with fields to update"),
+):
+    """Update an AI interview from a YAML file (partial updates OK)."""
+    data = _load_yaml(from_file)
+
+    client = PodojoClient()
+    try:
+        result = client.update_ai_interview(interview_id, data)
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 404:
+            console.print(f"[red]Error:[/red] AI interview '{interview_id}' not found")
+        else:
+            console.print(f"[red]Error:[/red] {_format_api_error(e)}")
+        raise typer.Exit(1)
+
+    console.print(f"[green]Updated AI interview:[/green] {result.get('interview_id', interview_id)}")
+
+
+@app.command("delete")
+def delete_ai_interview(
+    interview_id: str = typer.Argument(help="AI interview ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """Delete an AI interview."""
+    if not yes:
+        typer.confirm(f"Delete AI interview '{interview_id}'?", abort=True)
+
+    client = PodojoClient()
+    try:
+        client.delete_ai_interview(interview_id)
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 404:
+            console.print(f"[red]Error:[/red] AI interview '{interview_id}' not found")
+        else:
+            console.print(f"[red]Error:[/red] {_format_api_error(e)}")
+        raise typer.Exit(1)
+
+    console.print(f"[green]Deleted AI interview:[/green] {interview_id}")
+
+
+@app.command("validate")
+def validate(
+    file: Path = typer.Argument(help="YAML file to validate"),
+):
+    """Validate an AI interview YAML file without creating it."""
+    data = _load_yaml(file)
+
+    errors = validate_ai_interview_data(data)
+    if errors:
+        console.print("[red]Validation errors:[/red]")
+        for err in errors:
+            console.print(f"  {err}")
+        raise typer.Exit(1)
+
+    console.print("[green]Valid AI interview config.[/green]")
+
+
+@app.command("example")
+def example():
+    """Print an example AI interview YAML template."""
+    print(EXAMPLE_YAML)

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/src/podojo_cli/commands/usertests.py

@@ -70,7 +70,10 @@ project_name: checkout-redesign-q1
 # Each step requires: type ("screen" or "prototype") and title
 # Screen steps should have a variant: "question" (open-ended), "task" (action-based),
 # or "instruction" (briefing screen shown before a prototype step — uses a "Continue" button)
-# Optional per step: text (markdown), image (URL)
+# Optional per step: text (markdown), and either:
+#   image:      a URL to an externally-hosted image, or
+#   image_file: a path to a local image (uploaded to Podojo storage on create/update;
+#               relative paths resolve against this YAML file's location)
 steps:
   - type: screen
     variant: question
@@ -78,7 +81,7 @@ steps:
     text: |
       Look at this homepage screenshot.
       What stands out to you first?
-    image: https://example.com/screenshots/homepage.png
+    image_file: ./screenshots/homepage.png
 
   - type: screen
     variant: instruction
@@ -160,6 +163,35 @@ def _load_yaml(path: Path) -> dict:
     return data
 
 
+def _resolve_image_files(data: dict, base_dir: Path, client: PodojoClient) -> None:
+    """Upload any step `image_file` (local path) and replace it with the hosted URL."""
+    steps = data.get("steps")
+    if not isinstance(steps, list):
+        return
+    for i, step in enumerate(steps, 1):
+        if not isinstance(step, dict) or "image_file" not in step:
+            continue
+        raw_path = step.pop("image_file")
+        if not raw_path:
+            continue
+        image_path = Path(raw_path)
+        if not image_path.is_absolute():
+            image_path = (base_dir / image_path).resolve()
+        if not image_path.exists():
+            console.print(f"[red]Error:[/red] Step {i}: image file not found: {image_path}")
+            raise typer.Exit(1)
+        try:
+            result = client.upload_usertest_image(image_path)
+        except ValueError as ve:
+            console.print(f"[red]Error:[/red] Step {i}: {ve}")
+            raise typer.Exit(1)
+        except httpx.HTTPStatusError as he:
+            console.print(f"[red]Error:[/red] Step {i}: image upload failed: {_format_api_error(he)}")
+            raise typer.Exit(1)
+        step["image"] = result["url"]
+        console.print(f"[dim]Uploaded image for step {i}: {result['url']}[/dim]")
+
+
 def _format_api_error(e: httpx.HTTPStatusError) -> str:
     """Format API error into actionable message."""
     try:
@@ -257,6 +289,7 @@ def create_usertest(
         data["project_name"] = data["usertest_id"]
 
     client = PodojoClient()
+    _resolve_image_files(data, from_file.parent, client)
     try:
         result = client.create_usertest(data)
     except httpx.HTTPStatusError as e:
@@ -288,6 +321,7 @@ def update_usertest(
     data = _load_yaml(from_file)
 
     client = PodojoClient()
+    _resolve_image_files(data, from_file.parent, client)
     try:
         result = client.update_usertest(usertest_id, data)
     except httpx.HTTPStatusError as e:

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/src/podojo_cli/config.py

@@ -8,6 +8,7 @@ KEYRING_SERVICE = "podojo-cli"
 KEYRING_USERNAME = "api_key"
 CONFIG_PATH = Path.home() / ".podojo.toml"
 DEFAULT_BASE_URL = "https://podojo-fastapi-mcp.onrender.com"
+DEFAULT_AI_INTERVIEWS_URL = "https://podojo-unmod-discover-frontend.onrender.com"
 
 
 def load_config() -> dict:
@@ -15,6 +16,9 @@ def load_config() -> dict:
     if CONFIG_PATH.exists():
         config = tomllib.loads(CONFIG_PATH.read_text())
     config.setdefault("base_url", os.getenv("PODOJO_BASE_URL", DEFAULT_BASE_URL))
+    config.setdefault(
+        "ai_interviews_url", os.getenv("PODOJO_AI_INTERVIEWS_URL", DEFAULT_AI_INTERVIEWS_URL)
+    )
     api_key = (
         os.getenv("PODOJO_API_KEY")
         or keyring.get_password(KEYRING_SERVICE, KEYRING_USERNAME)

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/src/podojo_cli/main.py

@@ -1,6 +1,7 @@
 import typer
 
 from .commands import (
+    aiinterviews,
     auth,
     interviews,
     projects,
@@ -28,6 +29,7 @@ app.add_typer(auth.app, name="auth")
 app.add_typer(projects.app, name="projects")
 app.add_typer(interviews.app, name="interviews")
 app.add_typer(usertests.app, name="usertests")
+app.add_typer(aiinterviews.app, name="aiinterviews")
 app.add_typer(synth.app, name="synth")
 app.add_typer(transcripts.app, name="transcripts")
 app.add_typer(videos.app, name="videos")

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/tests/conftest.py

@@ -41,6 +41,7 @@ def mock_keyring():
 @pytest.fixture(autouse=True)
 def mock_config(monkeypatch):
     monkeypatch.setenv("PODOJO_BASE_URL", "http://test.local")
+    monkeypatch.setenv("PODOJO_AI_INTERVIEWS_URL", "http://interviews.test.local")
     monkeypatch.setenv("PODOJO_API_KEY", "test-key")
     monkeypatch.setattr("podojo_cli.config.CONFIG_PATH", Path("/nonexistent/.podojo.toml"))
 

podojo_cli-1.5.0/tests/test_aiinterviews.py

@@ -0,0 +1,328 @@
+import yaml
+
+from podojo_cli.commands.aiinterviews import EXAMPLE_YAML
+from podojo_cli.main import app
+
+
+VALID_AI_INTERVIEW_YAML = """\
+interview_id: test-interview-1
+title: Test AI Interview
+questions:
+  - section: Intro
+    text: Walk me through your last purchase.
+    max_follow_ups: 3
+    probe_for: Specific steps and pain points.
+  - text: What would you improve?
+closing_message: Thank you for your time!
+"""
+
+LIST_RESPONSE = {
+    "ai_interviews": [
+        {
+            "id": "abc1",
+            "interview_id": "ai-1",
+            "title": "Interview One",
+            "language": "en-US",
+            "question_count": 3,
+            "project_name": "proj-1",
+            "live": True,
+            "created_at": "2026-06-01T12:00:00",
+            "created_by": "user@example.com",
+            "last_updated": "2026-06-01T12:00:00",
+        },
+        {
+            "id": "abc2",
+            "interview_id": "ai-2",
+            "title": "Interview Two",
+            "language": "de-DE",
+            "question_count": 5,
+            "project_name": "proj-2",
+            "live": False,
+            "created_at": "2026-06-02T12:00:00",
+            "created_by": "user@example.com",
+            "last_updated": "2026-06-02T12:00:00",
+        },
+    ],
+    "total": 2,
+    "skip": 0,
+    "limit": 50,
+}
+
+GET_RESPONSE = {
+    "id": "abc123",
+    "interview_id": "ai-1",
+    "title": "Interview One",
+    "language": "en-US",
+    "project_name": "proj-1",
+    "overview": "Study overview",
+    "decision": "Improve the thing",
+    "questions": [{"text": "Walk me through your last purchase.", "max_follow_ups": 2}],
+    "closing_message": "Thanks!",
+    "live": False,
+    "group": "test-group",
+    "created_at": "2026-06-01T12:00:00",
+    "created_by": "user@example.com",
+    "last_updated": "2026-06-01T12:00:00",
+}
+
+
+def test_list_ai_interviews(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews?skip=0&limit=50",
+        json=LIST_RESPONSE,
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "list"])
+
+    assert result.exit_code == 0
+    assert "Interview One" in result.output
+    assert "Interview Two" in result.output
+
+
+def test_list_ai_interviews_empty(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews?skip=0&limit=50",
+        json={"ai_interviews": [], "total": 0, "skip": 0, "limit": 50},
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "list"])
+
+    assert result.exit_code == 0
+    assert "No AI interviews found" in result.output
+
+
+def test_get_ai_interview(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews/ai-1",
+        json=GET_RESPONSE,
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "get", "ai-1"])
+
+    assert result.exit_code == 0
+    assert "interview_id: ai-1" in result.output
+    assert "title: Interview One" in result.output
+    # Server-managed fields should be stripped
+    assert "created_at" not in result.output
+    assert "created_by" not in result.output
+    assert "group: test-group" not in result.output
+    # URLs should be displayed
+    assert "http://interviews.test.local/preview/test-group/ai-1" in result.output
+    assert "http://interviews.test.local/test-group/ai-1" in result.output
+
+
+def test_get_ai_interview_not_found(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews/nonexistent",
+        status_code=404,
+        json={"detail": "AI interview not found"},
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "get", "nonexistent"])
+
+    assert result.exit_code == 1
+    assert "not found" in result.output
+
+
+def test_create_ai_interview(runner, httpx_mock, tmp_path):
+    yaml_file = tmp_path / "interview.yaml"
+    yaml_file.write_text(VALID_AI_INTERVIEW_YAML)
+
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews",
+        method="POST",
+        json={
+            "id": "abc123",
+            "interview_id": "test-interview-1",
+            "title": "Test AI Interview",
+            "group": "test-group",
+        },
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 0
+    assert "test-interview-1" in result.output
+    assert "http://interviews.test.local/preview/test-group/test-interview-1" in result.output
+    assert "http://interviews.test.local/test-group/test-interview-1" in result.output
+
+
+def test_create_ai_interview_file_not_found(runner):
+    result = runner.invoke(app, ["aiinterviews", "create", "-f", "/nonexistent/interview.yaml"])
+
+    assert result.exit_code == 1
+    assert "File not found" in result.output
+
+
+def test_create_ai_interview_invalid_yaml(runner, tmp_path):
+    yaml_file = tmp_path / "bad.yaml"
+    yaml_file.write_text(":\n  invalid: [yaml\n  broken")
+
+    result = runner.invoke(app, ["aiinterviews", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "Invalid YAML" in result.output
+
+
+def test_create_ai_interview_missing_fields(runner, tmp_path):
+    yaml_file = tmp_path / "incomplete.yaml"
+    yaml_file.write_text("title: Just a title\n")
+
+    result = runner.invoke(app, ["aiinterviews", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "Missing required field" in result.output
+    assert "'interview_id'" in result.output
+
+
+def test_create_ai_interview_question_missing_text(runner, tmp_path):
+    yaml_file = tmp_path / "badquestion.yaml"
+    yaml_file.write_text(
+        "interview_id: test\n"
+        "title: Test\n"
+        "closing_message: Thanks!\n"
+        "questions:\n"
+        "  - section: Intro\n"
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "Question 1: missing required field 'text'" in result.output
+
+
+def test_create_ai_interview_invalid_max_follow_ups(runner, tmp_path):
+    yaml_file = tmp_path / "badfollowups.yaml"
+    yaml_file.write_text(
+        "interview_id: test\n"
+        "title: Test\n"
+        "closing_message: Thanks!\n"
+        "questions:\n"
+        "  - text: A question\n"
+        "    max_follow_ups: -1\n"
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "'max_follow_ups' must be an integer >= 0" in result.output
+
+
+def test_create_ai_interview_duplicate(runner, httpx_mock, tmp_path):
+    yaml_file = tmp_path / "interview.yaml"
+    yaml_file.write_text(VALID_AI_INTERVIEW_YAML)
+
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews",
+        method="POST",
+        status_code=409,
+        json={"detail": "AI interview with this ID already exists"},
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "already exists" in result.output
+
+
+def test_update_ai_interview(runner, httpx_mock, tmp_path):
+    yaml_file = tmp_path / "update.yaml"
+    yaml_file.write_text("title: Updated Title\n")
+
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews/ai-1",
+        method="PUT",
+        json={"interview_id": "ai-1", "title": "Updated Title"},
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "update", "ai-1", "-f", str(yaml_file)])
+
+    assert result.exit_code == 0
+    assert "Updated AI interview" in result.output
+
+
+def test_update_ai_interview_not_found(runner, httpx_mock, tmp_path):
+    yaml_file = tmp_path / "update.yaml"
+    yaml_file.write_text("title: Updated Title\n")
+
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews/nonexistent",
+        method="PUT",
+        status_code=404,
+        json={"detail": "AI interview not found"},
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "update", "nonexistent", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "not found" in result.output
+
+
+def test_delete_ai_interview(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews/ai-1",
+        method="DELETE",
+        json={"status": "deleted", "interview_id": "ai-1"},
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "delete", "ai-1", "--yes"])
+
+    assert result.exit_code == 0
+    assert "Deleted AI interview" in result.output
+
+
+def test_delete_ai_interview_not_found(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/ai-interviews/nonexistent",
+        method="DELETE",
+        status_code=404,
+        json={"detail": "AI interview not found"},
+    )
+
+    result = runner.invoke(app, ["aiinterviews", "delete", "nonexistent", "--yes"])
+
+    assert result.exit_code == 1
+    assert "not found" in result.output
+
+
+def test_validate_valid(runner, tmp_path):
+    yaml_file = tmp_path / "interview.yaml"
+    yaml_file.write_text(VALID_AI_INTERVIEW_YAML)
+
+    result = runner.invoke(app, ["aiinterviews", "validate", str(yaml_file)])
+
+    assert result.exit_code == 0
+    assert "Valid AI interview config" in result.output
+
+
+def test_validate_invalid(runner, tmp_path):
+    yaml_file = tmp_path / "bad.yaml"
+    yaml_file.write_text("title: Just a title\n")
+
+    result = runner.invoke(app, ["aiinterviews", "validate", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "Missing required field" in result.output
+
+
+def test_example(runner):
+    result = runner.invoke(app, ["aiinterviews", "example"])
+
+    assert result.exit_code == 0
+    assert "interview_id:" in result.output
+    assert "questions:" in result.output
+    assert "closing_message:" in result.output
+    assert "max_follow_ups:" in result.output
+
+
+def test_example_validates(runner, tmp_path):
+    data = yaml.safe_load(EXAMPLE_YAML)
+    assert isinstance(data, dict)
+
+    yaml_file = tmp_path / "example.yaml"
+    yaml_file.write_text(EXAMPLE_YAML)
+
+    result = runner.invoke(app, ["aiinterviews", "validate", str(yaml_file)])
+
+    assert result.exit_code == 0
+    assert "Valid AI interview config" in result.output

{podojo_cli-1.3.0 → podojo_cli-1.5.0}/uv.lock

@@ -369,7 +369,7 @@ wheels = [
 
 [[package]]
 name = "podojo-cli"
-version = "1.3.0"
+version = "1.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },