cctx-cli 1.1.0__tar.gz → 1.2.0__tar.gz

{cctx_cli-1.1.0 → cctx_cli-1.2.0}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 <!-- version list -->
 
+## v1.2.0 (2026-05-17)
+
+### Features
+
+- --until DATE, autopsy --json, export --format json (M12 #77 #78 #79)
+  ([#84](https://github.com/jacquardlabs/cctx/pull/84),
+  [`803b5f1`](https://github.com/jacquardlabs/cctx/commit/803b5f190404679ddef4cbbec7478d04c57b8413))
+
+
 ## v1.1.0 (2026-05-17)
 
 ### Chores

{cctx_cli-1.1.0 → cctx_cli-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cctx-cli
-Version: 1.1.0
+Version: 1.2.0
 Summary: Diagnose Claude Code sessions — find what went wrong, what it cost, and what to add to CLAUDE.md
 Author: Jacquard Labs
 License-Expression: MIT

{cctx_cli-1.1.0 → cctx_cli-1.2.0}/cctx/__init__.py

@@ -1,3 +1,3 @@
 """cctx: profile, debug, and optimize Claude Code and Agent SDK sessions."""
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"

{cctx_cli-1.1.0 → cctx_cli-1.2.0}/cctx/cli.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
+from typing import IO
 
 import rich_click as click
 
@@ -218,6 +219,14 @@ def ls(project: Path | None) -> None:
     type=str,
     help="Cross-session mode: 7, 7d, 2w, 2026-05-01, or 2026-05-01..2026-05-15.",
 )
+@click.option(
+    "--until",
+    "until_date",
+    default=None,
+    metavar="DATE",
+    type=str,
+    help="End date for --since window (YYYY-MM-DD). Requires --since.",
+)
 @click.option(
     "--latest",
     is_flag=True,
@@ -262,15 +271,24 @@ def ls(project: Path | None) -> None:
     type=click.IntRange(min=1),
     help="Show details for turn N (single-session only).",
 )
+@click.option(
+    "--json",
+    "json_out",
+    is_flag=True,
+    default=False,
+    help="Output diagnosis as JSON to stdout (single-session only).",
+)
 def autopsy(
     target: Path | None,
     since: str | None,
+    until_date: str | None,
     latest: bool,
     html_out: Path | None,
     github_summary: bool,
     fail_on_findings: bool,
     top_n: int | None,
     turn_num: int | None,
+    json_out: bool,
 ) -> None:
     """Diagnose a session or project directory.
 
@@ -290,6 +308,10 @@ def autopsy(
         raise click.UsageError("--top requires --since.")
     if turn_num is not None and since is not None:
         raise click.UsageError("--turn is not supported with --since.")
+    if until_date is not None and since is None:
+        raise click.UsageError("--until requires --since.")
+    if json_out and since is not None:
+        raise click.UsageError("--json is not supported with --since.")
 
     if target is None:
         if not latest:
@@ -326,6 +348,16 @@ def autopsy(
         # Cross-session path
         project_dir = target if target.is_dir() else target.parent
         start, end, label = parse_since(since)
+        if until_date is not None:
+            try:
+                end = datetime.fromisoformat(until_date.strip()).replace(
+                    tzinfo=UTC, hour=23, minute=59, second=59
+                )
+            except ValueError:
+                raise click.UsageError(
+                    f"Invalid --until date '{until_date}'. Expected YYYY-MM-DD."
+                ) from None
+            label = f"{label} until {until_date.strip()}"
         diagnoses = aggregate.run(project_dir, start, end)
         ev = evidence_mod.accumulate(diagnoses)
         if top_n is not None:
@@ -352,7 +384,12 @@ def autopsy(
         trace = tokenize_session(parse_session(target))
         diagnosis = diagnostician.run(trace)
         diagnosis = claude_md.generate(diagnosis)
-        if turn_num is not None:
+        if json_out:
+            import json as _json
+
+            from cctx.exporters.jsonl import export_diagnosis as _export_diag
+            click.echo(_json.dumps(_json.loads(_export_diag(diagnosis, trace)), indent=2))
+        elif turn_num is not None:
             render_turn(trace, diagnosis, turn_num)
         elif html_out is not None:
             from cctx.renderers.report import render_html
@@ -372,10 +409,10 @@ def autopsy(
 @click.option(
     "--format",
     "fmt",
-    type=click.Choice(["jsonl", "csv"]),
+    type=click.Choice(["jsonl", "csv", "json"]),
     default="jsonl",
     show_default=True,
-    help="Output format: jsonl (one object per session) or csv (one row per turn).",
+    help="Output format: jsonl (one object per session), csv (one row per turn), or json (array).",
 )
 @click.option(
     "--out",
@@ -397,6 +434,7 @@ def export(target: Path, fmt: str, out: Path | None, no_content: bool) -> None:
     import sys
 
     from cctx.exporters import csv as csv_mod
+    from cctx.exporters import json as json_mod
     from cctx.exporters import jsonl as jsonl_mod
 
     trace = tokenize_session(parse_session(target))
@@ -404,16 +442,19 @@ def export(target: Path, fmt: str, out: Path | None, no_content: bool) -> None:
     diagnosis = claude_md.generate(diagnosis)
     pairs = [(diagnosis, trace)]
 
+    def _write(fh: IO[str]) -> None:
+        if fmt == "jsonl":
+            jsonl_mod.write(pairs, fh, include_content=not no_content)
+        elif fmt == "json":
+            json_mod.write(pairs, fh, include_content=not no_content)
+        else:
+            csv_mod.write(pairs, fh)
+
     if out is not None:
         with open(out, "w", encoding="utf-8") as fh:
-            if fmt == "jsonl":
-                jsonl_mod.write(pairs, fh, include_content=not no_content)
-            else:
-                csv_mod.write(pairs, fh)
-    elif fmt == "jsonl":
-        jsonl_mod.write(pairs, sys.stdout, include_content=not no_content)
+            _write(fh)
     else:
-        csv_mod.write(pairs, sys.stdout)
+        _write(sys.stdout)
 
 
 @cli.command()

cctx_cli-1.2.0/cctx/exporters/json.py

@@ -0,0 +1,23 @@
+"""JSON exporter — full session array as pretty-printed JSON."""
+from __future__ import annotations
+
+import json
+from typing import IO, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from cctx.models import Diagnosis, SessionTrace
+
+from cctx.exporters.jsonl import export_diagnosis
+
+
+def write(
+    diagnoses: list[tuple[Diagnosis, SessionTrace]],
+    out: IO[str],
+    *,
+    include_content: bool = True,
+) -> None:
+    objects = [
+        json.loads(export_diagnosis(diagnosis, trace, include_content=include_content))
+        for diagnosis, trace in diagnoses
+    ]
+    out.write(json.dumps(objects, indent=2) + "\n")

{cctx_cli-1.1.0 → cctx_cli-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cctx-cli"
-version = "1.1.0"
+version = "1.2.0"
 description = "Diagnose Claude Code sessions — find what went wrong, what it cost, and what to add to CLAUDE.md"
 readme = "README.md"
 requires-python = ">=3.10"

{cctx_cli-1.1.0 → cctx_cli-1.2.0}/tests/test_cli.py

@@ -389,3 +389,162 @@ def test_turn_out_of_range_shows_not_found(runner, session_jsonl):
     )
     assert result.exit_code == 0
     assert "not found" in result.output.lower() or "999" in result.output
+
+
+# ---------------------------------------------------------------------------
+# --until DATE tests (#77)
+# ---------------------------------------------------------------------------
+
+
+def test_until_requires_since(runner, session_jsonl):
+    """--until without --since → non-zero exit (UsageError)."""
+    from cctx.cli import cli
+
+    result = runner.invoke(cli, ["autopsy", str(session_jsonl), "--until", "2026-05-15"])
+    assert result.exit_code != 0
+    assert "since" in result.output.lower() or "Error" in result.output
+
+
+def test_until_with_since_accepted(runner, tmp_path):
+    """--until DATE + --since → exit 0."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+    session_id = "until-test-sess"
+    line = {
+        "type": "user", "uuid": f"{session_id}-u1", "parentUuid": None,
+        "isSidechain": False, "timestamp": "2026-05-14T10:00:00.000Z",
+        "sessionId": session_id, "version": "2.1.138",
+        "cwd": "/Users/test/Projects/demo", "gitBranch": "main",
+        "userType": "external", "entrypoint": "cli",
+        "message": {"role": "user", "content": "hello"},
+    }
+    (project_dir / f"{session_id}.jsonl").write_text(json.dumps(line) + "\n")
+
+    result = runner.invoke(
+        cli,
+        ["autopsy", str(project_dir), "--since", "7", "--until", "2026-05-15"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+
+
+def test_until_invalid_date(runner, tmp_path):
+    """--until with a non-date string → non-zero exit."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+
+    result = runner.invoke(
+        cli, ["autopsy", str(project_dir), "--since", "7", "--until", "not-a-date"],
+    )
+    assert result.exit_code != 0
+
+
+def test_until_label_includes_date(runner, tmp_path):
+    """--until DATE appears in the period label in aggregate output."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+    session_id = "until-label-sess"
+    line = {
+        "type": "user", "uuid": f"{session_id}-u1", "parentUuid": None,
+        "isSidechain": False, "timestamp": "2026-05-10T10:00:00.000Z",
+        "sessionId": session_id, "version": "2.1.138",
+        "cwd": "/Users/test/Projects/demo", "gitBranch": "main",
+        "userType": "external", "entrypoint": "cli",
+        "message": {"role": "user", "content": "hello"},
+    }
+    (project_dir / f"{session_id}.jsonl").write_text(json.dumps(line) + "\n")
+
+    result = runner.invoke(
+        cli,
+        ["autopsy", str(project_dir), "--since", "30", "--until", "2026-05-15"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    assert "2026-05-15" in result.output
+
+
+# ---------------------------------------------------------------------------
+# autopsy --json tests (#78)
+# ---------------------------------------------------------------------------
+
+
+def test_autopsy_json_outputs_valid_json(runner, session_jsonl):
+    """--json flag produces valid JSON on stdout."""
+    from cctx.cli import cli
+
+    result = runner.invoke(
+        cli, ["autopsy", str(session_jsonl), "--json"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "session_id" in data
+    assert "findings" in data
+
+
+def test_autopsy_json_incompatible_with_since(runner, tmp_path):
+    """--json + --since → non-zero exit (UsageError)."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+
+    result = runner.invoke(
+        cli, ["autopsy", str(project_dir), "--since", "7", "--json"],
+    )
+    assert result.exit_code != 0
+
+
+def test_autopsy_json_contains_cost(runner, session_jsonl):
+    """--json output includes cost fields."""
+    from cctx.cli import cli
+
+    result = runner.invoke(
+        cli, ["autopsy", str(session_jsonl), "--json"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "total_cost_usd" in data
+    assert "waste_cost_usd" in data
+
+
+# ---------------------------------------------------------------------------
+# export --format json tests (#79)
+# ---------------------------------------------------------------------------
+
+
+def test_export_json_produces_valid_json(runner, session_jsonl):
+    """export --format json produces a valid JSON array."""
+    from cctx.cli import cli
+
+    result = runner.invoke(
+        cli, ["export", str(session_jsonl), "--format", "json"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert isinstance(data, list)
+    assert len(data) == 1
+    assert "session_id" in data[0]
+
+
+def test_export_json_to_file(runner, session_jsonl, tmp_path):
+    """export --format json --out FILE writes a valid JSON file."""
+    from cctx.cli import cli
+
+    out_path = tmp_path / "out.json"
+    result = runner.invoke(
+        cli, ["export", str(session_jsonl), "--format", "json", "--out", str(out_path)],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    data = json.loads(out_path.read_text())
+    assert isinstance(data, list)
+    assert data[0]["session_id"] == "test-sess-01"