reprompt-cli 2.0.0__tar.gz → 2.0.1__tar.gz

{reprompt_cli-2.0.0 → reprompt_cli-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 2.0.0
+Version: 2.0.1
 Summary: Discover, analyze, and optimize your prompts from AI coding sessions
 Project-URL: Homepage, https://github.com/reprompt-dev/reprompt
 Project-URL: Repository, https://github.com/reprompt-dev/reprompt

{reprompt_cli-2.0.0 → reprompt_cli-2.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reprompt-cli"
-version = "2.0.0"
+version = "2.0.1"
 description = "Discover, analyze, and optimize your prompts from AI coding sessions"
 readme = "README.md"
 license = { text = "MIT" }

{reprompt_cli-2.0.0 → reprompt_cli-2.0.1}/src/reprompt/__init__.py

@@ -1,6 +1,6 @@
 """reprompt — Discover, analyze, and evolve your best prompts from AI coding sessions."""
 
-__version__ = "2.0.0"
+__version__ = "2.0.1"
 
 __all__ = [
     "__version__",

{reprompt_cli-2.0.0 → reprompt_cli-2.0.1}/src/reprompt/cli.py

@@ -2046,6 +2046,57 @@ debug-needs-reference = true
     console.print("  Edit rules, then run [bold]reprompt lint[/bold] to verify.")
 
 
+@app.command(rich_help_panel="Analyze")
+def projects(
+    source: str = typer.Option(
+        None, "--source", "-s", help="Filter by source (e.g. claude-code, cursor)"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    copy: bool = typer.Option(False, "--copy", help="Copy result to clipboard"),
+) -> None:
+    """Compare prompt quality across projects.
+
+    Shows per-project breakdown: sessions, prompts, quality scores,
+    efficiency, focus, and frustration signals.
+
+    Examples:
+
+        reprompt projects                          # all projects
+
+        reprompt projects --source claude-code      # filter by source
+
+        reprompt projects --json                   # machine-readable
+    """
+    import json as json_mod
+
+    from reprompt.config import Settings
+    from reprompt.output.projects_terminal import render_projects_table
+    from reprompt.storage.db import PromptDB
+
+    settings = Settings()
+    db = PromptDB(settings.db_path)
+
+    project_data = db.get_project_summary(source=source)
+
+    if json_output:
+        print(json_mod.dumps(project_data, indent=2, default=str))
+    else:
+        output = render_projects_table(project_data)
+        print(output)
+
+    if copy:
+        if json_output:
+            _copy_to_clip(json_mod.dumps(project_data, indent=2, default=str), quiet=True)
+        else:
+            _copy_to_clip(output)
+
+    from reprompt.core.suggestions import get_suggestion
+
+    hint = get_suggestion("projects")
+    if hint and not json_output:
+        console.print(f"  [dim]→ Try: {hint}[/dim]\n")
+
+
 @app.command(rich_help_panel="Analyze")
 def sessions(
     last: int = typer.Option(10, "--last", help="Show N most recent sessions"),

{reprompt_cli-2.0.0 → reprompt_cli-2.0.1}/src/reprompt/core/suggestions.py

@@ -24,6 +24,7 @@ SUGGESTIONS: dict[str, str] = {
     "template": "reprompt insights (see which patterns work best)",
     "lint": "reprompt init (generate .reprompt.toml) · reprompt rewrite (improve prompts)",
     "rewrite": "reprompt compress (reduce tokens) · reprompt score (verify improvement)",
+    "projects": "reprompt sessions --detail <id> (deep-dive) · reprompt insights (patterns)",
 }
 
 

reprompt_cli-2.0.1/src/reprompt/output/projects_terminal.py

@@ -0,0 +1,101 @@
+"""Rich terminal output for projects command."""
+
+from __future__ import annotations
+
+from io import StringIO
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+def _score_style(score: float | None) -> str:
+    if score is None:
+        return "dim"
+    if score >= 80:
+        return "bold green"
+    if score >= 60:
+        return "green"
+    if score >= 40:
+        return "yellow"
+    return "red"
+
+
+def render_projects_table(projects: list[dict[str, Any]]) -> str:
+    """Render project quality summary as a Rich table."""
+    buf = StringIO()
+    console = Console(file=buf, width=110, record=True)
+
+    if not projects:
+        console.print("\n  [dim]No project data. Run [bold]reprompt scan[/bold] first.[/dim]\n")
+        return buf.getvalue()
+
+    # Header stats
+    total_sessions = sum(p.get("session_count", 0) for p in projects)
+    total_prompts = sum(p.get("prompt_count", 0) or 0 for p in projects)
+    quality_scores = [p["avg_quality"] for p in projects if p.get("avg_quality") is not None]
+    avg_quality = round(sum(quality_scores) / len(quality_scores), 1) if quality_scores else 0
+
+    console.print(
+        Panel(
+            f"  [bold]{len(projects)}[/bold] projects · "
+            f"[bold]{total_sessions}[/bold] sessions · "
+            f"[bold]{total_prompts}[/bold] prompts · "
+            f"avg quality [bold]{avg_quality}[/bold]/100",
+            title="[bold]Project Quality[/bold]",
+            border_style="blue",
+        )
+    )
+
+    # Table
+    table = Table(show_header=True, header_style="bold", padding=(0, 1), expand=True)
+    table.add_column("Project", style="bold", min_width=12)
+    table.add_column("Sessions", justify="right", width=8)
+    table.add_column("Prompts", justify="right", width=8)
+    table.add_column("Quality", justify="right", width=8)
+    table.add_column("Efficiency", justify="right", width=10)
+    table.add_column("Focus", justify="right", width=7)
+    table.add_column("Frustration", justify="right", width=11)
+    table.add_column("Source", width=14)
+
+    for p in projects:
+        quality = p.get("avg_quality")
+        efficiency = p.get("avg_efficiency")
+        focus = p.get("avg_focus")
+
+        abandon = p.get("abandonment_count", 0) or 0
+        escalate = p.get("escalation_count", 0) or 0
+        frustration_total = abandon + escalate
+        sessions = p.get("session_count", 0)
+        frust_pct = round(frustration_total / sessions * 100) if sessions > 0 else 0
+
+        q_str = f"[{_score_style(quality)}]{quality:.0f}[/]" if quality else "[dim]--[/dim]"
+        e_str = (
+            f"[{_score_style(efficiency)}]{efficiency:.0f}[/]" if efficiency else "[dim]--[/dim]"
+        )
+        f_str = f"[{_score_style(focus)}]{focus:.0f}[/]" if focus else "[dim]--[/dim]"
+
+        frust_style = "red" if frust_pct > 30 else "yellow" if frust_pct > 15 else "dim"
+        frust_str = f"[{frust_style}]{frust_pct}%[/]" if frustration_total > 0 else "[dim]--[/dim]"
+
+        sources = p.get("sources", "")
+        # Shorten source names
+        short_sources = (
+            sources.replace("claude-code", "claude").replace("-ext", "") if sources else ""
+        )
+
+        table.add_row(
+            p.get("project", "unknown"),
+            str(sessions),
+            str(p.get("prompt_count", 0) or 0),
+            q_str,
+            e_str,
+            f_str,
+            frust_str,
+            short_sources,
+        )
+
+    console.print(table)
+    console.print()
+    return buf.getvalue()

{reprompt_cli-2.0.0 → reprompt_cli-2.0.1}/src/reprompt/storage/db.py

@@ -809,6 +809,50 @@ class PromptDB:
         finally:
             conn.close()
 
+    def get_project_summary(self, source: str | None = None) -> list[dict[str, Any]]:
+        """Return per-project quality summary aggregated from session_meta.
+
+        Returns list of dicts with: project, session_count, prompt_count,
+        avg_quality, avg_efficiency, avg_focus, avg_outcome, abandonment_count,
+        escalation_count, sources, earliest, latest.
+        """
+        conn = self._conn()
+        try:
+            base_query = """
+                SELECT
+                    COALESCE(sm.project, 'unknown') as project,
+                    COUNT(DISTINCT sm.session_id) as session_count,
+                    SUM(sm.prompt_count) as prompt_count,
+                    ROUND(AVG(CASE WHEN sm.quality_score IS NOT NULL
+                        THEN sm.quality_score END), 1) as avg_quality,
+                    ROUND(AVG(CASE WHEN sm.efficiency_score IS NOT NULL
+                        THEN sm.efficiency_score END), 1) as avg_efficiency,
+                    ROUND(AVG(CASE WHEN sm.focus_score IS NOT NULL
+                        THEN sm.focus_score END), 1) as avg_focus,
+                    ROUND(AVG(CASE WHEN sm.outcome_score IS NOT NULL
+                        THEN sm.outcome_score END), 1) as avg_outcome,
+                    SUM(COALESCE(sm.has_abandonment, 0)) as abandonment_count,
+                    SUM(COALESCE(sm.has_escalation, 0)) as escalation_count,
+                    GROUP_CONCAT(DISTINCT sm.source) as sources,
+                    MIN(sm.start_time) as earliest,
+                    MAX(sm.end_time) as latest
+                FROM session_meta sm
+                WHERE sm.project IS NOT NULL AND sm.project != ''
+            """
+            if source:
+                base_query += " AND sm.source = ?"
+                rows = conn.execute(
+                    base_query + " GROUP BY sm.project ORDER BY session_count DESC",
+                    (source,),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    base_query + " GROUP BY sm.project ORDER BY session_count DESC"
+                ).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            conn.close()
+
     def get_effectiveness_for_session(self, session_id: str) -> float | None:
         """Return effectiveness_score for a session, or None if not found."""
         conn = self._conn()

reprompt_cli-2.0.1/tests/test_projects.py

@@ -0,0 +1,200 @@
+"""Tests for reprompt projects command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from reprompt.output.projects_terminal import render_projects_table
+from reprompt.storage.db import PromptDB
+
+
+def _meta(db: PromptDB, session_id: str, project: str, source: str = "claude-code", **kw):
+    """Helper to insert session_meta with required fields."""
+    db.upsert_session_meta(
+        session_id=session_id,
+        source=source,
+        project=project,
+        start_time=kw.get("start_time", "2026-03-15T10:00:00Z"),
+        end_time=kw.get("end_time", "2026-03-15T11:00:00Z"),
+        duration_seconds=kw.get("duration_seconds", 3600),
+        prompt_count=kw.get("prompt_count", 10),
+        tool_call_count=kw.get("tool_call_count", 5),
+        error_count=kw.get("error_count", 0),
+        final_status=kw.get("final_status", "completed"),
+        avg_prompt_length=kw.get("avg_prompt_length", 50.0),
+        effectiveness_score=kw.get("effectiveness_score", 0.7),
+    )
+
+
+class TestGetProjectSummary:
+    def test_empty_db(self, tmp_path: Path) -> None:
+        db = PromptDB(tmp_path / "test.db")
+        assert db.get_project_summary() == []
+
+    def test_single_project(self, tmp_path: Path) -> None:
+        db = PromptDB(tmp_path / "test.db")
+        _meta(db, "s1", "myproject", prompt_count=5)
+        result = db.get_project_summary()
+        assert len(result) == 1
+        assert result[0]["project"] == "myproject"
+        assert result[0]["session_count"] == 1
+        assert result[0]["prompt_count"] == 5
+
+    def test_multiple_projects(self, tmp_path: Path) -> None:
+        db = PromptDB(tmp_path / "test.db")
+        for i, proj in enumerate(["alpha", "beta", "gamma"]):
+            for j in range(i + 1):
+                _meta(db, f"{proj}-s{j}", proj)
+        result = db.get_project_summary()
+        assert len(result) == 3
+        assert result[0]["project"] == "gamma"
+        assert result[0]["session_count"] == 3
+
+    def test_source_filter(self, tmp_path: Path) -> None:
+        db = PromptDB(tmp_path / "test.db")
+        _meta(db, "s1", "proj1", source="claude-code")
+        _meta(db, "s2", "proj2", source="cursor")
+        result = db.get_project_summary(source="claude-code")
+        assert len(result) == 1
+        assert result[0]["project"] == "proj1"
+
+    def test_quality_scores(self, tmp_path: Path) -> None:
+        db = PromptDB(tmp_path / "test.db")
+        _meta(db, "s1", "myproject")
+        db.upsert_session_quality(
+            session_id="s1",
+            quality_score=75.0,
+            prompt_quality_score=70.0,
+            efficiency_score=80.0,
+            focus_score=85.0,
+            outcome_score=65.0,
+            has_abandonment=False,
+            has_escalation=False,
+            stall_turns=0,
+            session_type="feature-dev",
+            quality_insight="Good",
+        )
+        result = db.get_project_summary()
+        assert len(result) == 1
+        assert result[0]["avg_quality"] == 75.0
+        assert result[0]["avg_efficiency"] == 80.0
+
+    def test_frustration_counts(self, tmp_path: Path) -> None:
+        db = PromptDB(tmp_path / "test.db")
+        for i in range(3):
+            _meta(db, f"s{i}", "troubled", error_count=3)
+            db.upsert_session_quality(
+                session_id=f"s{i}",
+                quality_score=40.0,
+                prompt_quality_score=35.0,
+                efficiency_score=30.0,
+                focus_score=45.0,
+                outcome_score=40.0,
+                has_abandonment=i < 2,
+                has_escalation=i == 0,
+                stall_turns=2,
+                session_type="debug",
+                quality_insight="Frustrating",
+            )
+        result = db.get_project_summary()
+        assert result[0]["abandonment_count"] == 2
+        assert result[0]["escalation_count"] == 1
+
+    def test_excludes_empty_project(self, tmp_path: Path) -> None:
+        db = PromptDB(tmp_path / "test.db")
+        _meta(db, "s1", "")
+        _meta(db, "s2", "real-project")
+        result = db.get_project_summary()
+        assert len(result) == 1
+        assert result[0]["project"] == "real-project"
+
+
+class TestRenderProjectsTable:
+    def test_empty_projects(self) -> None:
+        output = render_projects_table([])
+        assert "No project data" in output
+
+    def test_renders_table(self) -> None:
+        data = [
+            {
+                "project": "myproject",
+                "session_count": 10,
+                "prompt_count": 50,
+                "avg_quality": 72.0,
+                "avg_efficiency": 65.0,
+                "avg_focus": 80.0,
+                "avg_outcome": None,
+                "abandonment_count": 1,
+                "escalation_count": 0,
+                "sources": "claude-code",
+                "earliest": None,
+                "latest": None,
+            }
+        ]
+        output = render_projects_table(data)
+        assert "myproject" in output
+        assert "72" in output
+
+    def test_multiple_projects(self) -> None:
+        data = [
+            {
+                "project": "alpha",
+                "session_count": 5,
+                "prompt_count": 20,
+                "avg_quality": 80.0,
+                "avg_efficiency": 75.0,
+                "avg_focus": 85.0,
+                "avg_outcome": None,
+                "abandonment_count": 0,
+                "escalation_count": 0,
+                "sources": "claude-code",
+                "earliest": None,
+                "latest": None,
+            },
+            {
+                "project": "beta",
+                "session_count": 3,
+                "prompt_count": 15,
+                "avg_quality": 45.0,
+                "avg_efficiency": 40.0,
+                "avg_focus": 50.0,
+                "avg_outcome": None,
+                "abandonment_count": 2,
+                "escalation_count": 1,
+                "sources": "cursor",
+                "earliest": None,
+                "latest": None,
+            },
+        ]
+        output = render_projects_table(data)
+        assert "alpha" in output
+        assert "beta" in output
+        assert "2 projects" in output
+
+
+class TestProjectsCLI:
+    def test_help(self) -> None:
+        from typer.testing import CliRunner
+
+        from reprompt.cli import app
+
+        runner = CliRunner()
+        result = runner.invoke(app, ["projects", "--help"])
+        assert result.exit_code == 0
+        assert "project" in result.output.lower()
+
+    def test_empty_json(self, tmp_path: Path) -> None:
+        import json
+        import os
+
+        from typer.testing import CliRunner
+
+        from reprompt.cli import app
+
+        os.environ["REPROMPT_DB_PATH"] = str(tmp_path / "test.db")
+        runner = CliRunner()
+        result = runner.invoke(app, ["projects", "--json"])
+        del os.environ["REPROMPT_DB_PATH"]
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data == []

{reprompt_cli-2.0.0 → reprompt_cli-2.0.1}/tests/test_suggestions.py

@@ -19,6 +19,7 @@ class TestGetSuggestion:
             "template",
             "lint",
             "rewrite",
+            "projects",
         }
         assert set(SUGGESTIONS.keys()) == expected