pisces-cli 0.1.0__py3-none-any.whl

pisces/history_cmd.py

@@ -0,0 +1,313 @@
+"""
+pisces.history_cmd
+~~~~~~~~~~~~~~~~~~
+Implements `pisces history` — browse and inspect past repair attempts.
+
+Storage layout:
+    .pisces/history/
+        <repair_id>/
+            metadata.json   ← state, finding, judge result, timestamps
+            original.py     ← file content BEFORE the patch
+            patch.py        ← the proposed replacement code block
+
+Commands:
+    pisces history           — list all repairs, newest first
+    pisces history <id>      — show full detail + diff for one repair
+"""
+
+from __future__ import annotations
+
+import difflib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from rich import box
+from rich.table import Table
+
+from pisces.tui import (
+    _sev_badge,
+    console,
+    print_diff,
+    print_error,
+    print_section,
+    print_warning,
+)
+
+_HISTORY_DIR = ".pisces/history"
+
+# State → display colour
+_STATE_COLORS = {
+    "SUCCEEDED": "bold green",
+    "ROLLED_BACK": "bold red",
+    "REJECTED": "red",
+    "FAILED": "dim red",
+    "HEALING": "yellow",
+    "APPLIED": "cyan",
+    "DETECTED": "dim",
+    "PROPOSED": "dim",
+}
+
+
+# ─────────────────────────────────────────────────────────────
+# Entry point
+# ─────────────────────────────────────────────────────────────
+
+
+def run_history(
+    project_root: Path,
+    repair_id: str | None = None,
+    limit: int = 20,
+) -> int:
+    """
+    Entry point for `pisces history`.
+
+    If `repair_id` is given, show full detail for that repair.
+    Otherwise list all repairs, newest first.
+
+    Returns 0 on success, 1 on error.
+    """
+    print_section("pisces history")
+
+    history_root = project_root / _HISTORY_DIR
+
+    if not history_root.exists():
+        console.print("[muted]No repair history found. Run 'pisces fix <file:line>' first.[/]")
+        return 0
+
+    records = _load_all_records(history_root)
+
+    if not records:
+        console.print("[muted]No repair records found.[/]")
+        return 0
+
+    if repair_id:
+        # Detail view for one repair
+        record = next((r for r in records if r["repair_id"] == repair_id), None)
+        if record is None:
+            print_error(f"Repair ID '{repair_id}' not found.")
+            return 1
+        _show_detail(record, history_root)
+        return 0
+
+    # List view
+    _show_list(records, limit=limit)
+    console.print(
+        "  [dim]Tip:[/] [cyan]pisces history <repair_id>[/] "
+        "[dim]to see diff + full details for any repair.[/]"
+    )
+    return 0
+
+
+# ─────────────────────────────────────────────────────────────
+# List view
+# ─────────────────────────────────────────────────────────────
+
+
+def _show_list(records: list[dict], limit: int) -> None:
+    """Render a table of all repair records."""
+    sorted_records = sorted(
+        records,
+        key=lambda r: r.get("created_at", ""),
+        reverse=True,
+    )[:limit]
+
+    table = Table(
+        title=f"[bold]Repair History[/] [dim]({len(records)} total, showing {len(sorted_records)})[/]",
+        title_justify="left",
+        box=box.ROUNDED,
+        border_style="blue",
+        header_style="bold cyan",
+        show_lines=False,
+        padding=(0, 1),
+    )
+
+    table.add_column("Repair ID", style="code", width=10, no_wrap=True)
+    table.add_column("State", style="bold", min_width=14)
+    table.add_column("Severity", style="bold", width=12)
+    table.add_column("Rule", style="code", min_width=25)
+    table.add_column("File", style="cyan", min_width=25, max_width=40)
+    table.add_column("When", style="dim", min_width=16)
+
+    for r in sorted_records:
+        state = r.get("state", "?")
+        finding = r.get("finding", {})
+        sev = finding.get("severity", "INFO").upper()
+        ts = _fmt_time(r.get("created_at", ""))
+        color = _STATE_COLORS.get(state, "white")
+
+        table.add_row(
+            r.get("repair_id", "?"),
+            f"[{color}]{state}[/]",
+            _sev_badge(sev),
+            finding.get("rule", "?"),
+            f"{finding.get('file', '?')}:{finding.get('line', '?')}",
+            ts,
+        )
+
+    console.print(table)
+    console.print()
+
+    # Summary counts
+    states = [r.get("state", "?") for r in records]
+    succeeded = states.count("SUCCEEDED")
+    failed = states.count("ROLLED_BACK") + states.count("FAILED")
+    rejected = states.count("REJECTED")
+
+    console.print(
+        f"  [success]✓ {succeeded} succeeded[/]  "
+        f"[high]✗ {failed} failed/rolled back[/]  "
+        f"[dim]⊘ {rejected} rejected[/]"
+    )
+    console.print()
+
+
+# ─────────────────────────────────────────────────────────────
+# Detail view
+# ─────────────────────────────────────────────────────────────
+
+
+def _show_detail(record: dict, history_root: Path) -> None:
+    """Render the full detail panel for one repair record."""
+    from rich.panel import Panel
+    from rich.table import Table
+
+    repair_id = record.get("repair_id", "?")
+    state = record.get("state", "?")
+    finding = record.get("finding", {})
+    judge = record.get("judge_result") or {}
+    color = _STATE_COLORS.get(state, "white")
+
+    # ── Metadata grid ─────────────────────────────────────────
+    grid = Table.grid(padding=(0, 2))
+    grid.add_column(style="dim", min_width=18)
+    grid.add_column(style="white", min_width=30)
+
+    grid.add_row("Repair ID", f"[code]{repair_id}[/]")
+    grid.add_row("State", f"[{color}]{state}[/]")
+    grid.add_row("Rule", f"[code]{finding.get('rule', '?')}[/]")
+    grid.add_row("Severity", _sev_badge(finding.get("severity", "INFO")))
+    grid.add_row("File", f"[cyan]{finding.get('file', '?')}:{finding.get('line', '?')}[/]")
+    grid.add_row("Description", finding.get("description", ""))
+    grid.add_row("Created", _fmt_time(record.get("created_at", "")))
+    grid.add_row(
+        "Human approved",
+        "[success]Yes[/]"
+        if record.get("human_approved") is True
+        else "[high]No[/]"
+        if record.get("human_approved") is False
+        else "[dim]N/A[/]",
+    )
+
+    console.print(
+        Panel(
+            grid,
+            title=f"[bold]Repair Detail — {repair_id}[/]",
+            border_style="blue",
+            padding=(0, 2),
+        )
+    )
+    console.print()
+
+    # ── Judge result ──────────────────────────────────────────
+    if judge:
+        jt = Table.grid(padding=(0, 2))
+        jt.add_column(style="dim", min_width=20)
+        jt.add_column(style="white", min_width=20)
+
+        dec = judge.get("decision", "?")
+        dcol = "success" if dec == "APPROVED" else "high"
+
+        jt.add_row("Decision", f"[{dcol}]{dec}[/]")
+        jt.add_row("Security fixed", _badge(judge.get("security_ok")))
+        jt.add_row("Functionality ok", _badge(judge.get("functionality_ok")))
+        jt.add_row("Regression risk", judge.get("regression_risk", "?"))
+        jt.add_row("Quality", judge.get("patch_quality", "?"))
+        jt.add_row("Completeness", judge.get("completeness", "?"))
+        jt.add_row("Reasoning", f"[dim]{judge.get('reasoning', '')[:200]}[/]")
+
+        console.print(
+            Panel(
+                jt,
+                title="[bold]Judge Score[/]",
+                border_style="dim green",
+                padding=(0, 2),
+            )
+        )
+        console.print()
+
+    # ── Diff ──────────────────────────────────────────────────
+    repair_dir = history_root / repair_id
+    original_file = repair_dir / "original.py"
+    patch_file = repair_dir / "patch.py"
+
+    if original_file.exists() and patch_file.exists():
+        original = original_file.read_text(encoding="utf-8")
+        patched = patch_file.read_text(encoding="utf-8")
+        console.print("[bold]Patch Diff:[/]")
+
+        diff_text = "".join(
+            difflib.unified_diff(
+                original.splitlines(keepends=True),
+                patched.splitlines(keepends=True),
+                fromfile=f"a/{finding.get('file', 'original.py')}",
+                tofile=f"b/{finding.get('file', 'patched.py')}",
+            )
+        )
+
+        print_diff(
+            diff_text=diff_text or "No differences detected.\n",
+            filename=finding.get("file", ""),
+        )
+    else:
+        console.print("[muted]No patch diff available (files not found).[/]")
+        console.print()
+
+
+# ─────────────────────────────────────────────────────────────
+# Record loading
+# ─────────────────────────────────────────────────────────────
+
+
+def _load_all_records(history_root: Path) -> list[dict]:
+    """Load all metadata.json files from .pisces/history/*/."""
+    records: list[dict] = []
+    for meta_file in history_root.glob("*/metadata.json"):
+        try:
+            data = json.loads(meta_file.read_text(encoding="utf-8"))
+            records.append(data)
+        except (json.JSONDecodeError, OSError):
+            print_warning(f"Skipping corrupt record: {meta_file}")
+    return records
+
+
+# ─────────────────────────────────────────────────────────────
+# Formatting helpers
+# ─────────────────────────────────────────────────────────────
+
+
+def _fmt_time(iso: str) -> str:
+    """Convert an ISO timestamp to a human-readable relative string."""
+    try:
+        dt = datetime.fromisoformat(iso)
+        now = datetime.now(timezone.utc)
+        diff_s = (now - dt).total_seconds()
+
+        if diff_s < 60:
+            return "just now"
+        if diff_s < 3600:
+            return f"{int(diff_s // 60)}m ago"
+        if diff_s < 86400:
+            return f"{int(diff_s // 3600)}h ago"
+        if diff_s < 604800:
+            return f"{int(diff_s // 86400)}d ago"
+        return dt.strftime("%Y-%m-%d")
+    except (TypeError, ValueError, OverflowError):
+        return iso[:16] if len(iso) >= 16 else iso
+
+
+def _badge(val: Any) -> str:
+    if val is True or str(val).lower() == "true":
+        return "[success]✓ yes[/]"
+    return "[high]✗ no[/]"

pisces/init_cmd.py

@@ -0,0 +1,193 @@
+"""This implements the pisces init command for project initialization"""
+
+# Can be run multiple times(idempotent).abs
+# creates pisces.toml and the .pisces/ state directory
+# NEVER destructively overwrites without --force
+# Adds .pisces to .gitignore if it exists.abs
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from pisces.tui import (
+    console,
+    print_section,
+    print_step_fail,
+    print_step_ok,
+    print_step_running,
+    print_success,
+    print_warning,
+)
+
+## default pisces.toml template
+
+_DEFAULT_PISCES_TOML = """\
+# pisces project configuration
+# API keys MUST come from environment variables — never put them here.
+# See: https://github.com/richochetclementine1315/pisces#configuration
+[llm]
+# Supported providers: openai, anthropic, gemini, groq, ollama, lmstudio
+provider = "groq"
+model    = "llama-3.3-70b-versatile"
+[repair]
+max_attempts     = 3
+require_approval = true   # HITL — always ask before modifying source
+[validation]
+# Command used to run your project's test suite after patching.
+# pisces will detect 'pytest' automatically if you leave this empty.
+test_command = "pytest"
+[scan]
+# Paths to exclude from scanning (relative globs)
+exclude = [
+    ".git",
+    ".venv",
+    "venv",
+    "__pycache__",
+    "node_modules",
+    ".pisces",
+    "dist",
+    "build",
+]
+"""
+
+"""Default context.json template"""
+
+
+def _default_context(project_root: Path) -> dict:
+    return {
+        "schema_version": "1",
+        "project": {
+            "root": str(project_root),
+            "initialized_at": datetime.now(timezone.utc).isoformat(),
+        },
+        "files": {},
+    }
+
+
+"""Main init logic"""
+
+
+def run_init(project_root: Path, *, force: bool = False) -> int:
+    """initialize pisces in *project_root*. , return 0 as success and 1 as errror."""
+    print_section("pisces init")
+    console.print(f" [dim]Project root:[/] [cyan]{project_root}[/]")
+    console.print()
+
+    # 1.Validation of the project root very important bro!
+    if not project_root.exists():
+        print_step_fail(f"Directory does not exists: {project_root}")
+        return 1
+    if not project_root.is_dir():
+        print_step_fail(f"Not a directory: {project_root}")
+        return 1
+
+    # 2.pisces.toml
+    toml_path = project_root / "pisces.toml"
+    _init_pisces_toml(toml_path, force=force)
+
+    # 3. .pisces/ state directories basically like cache, history context.json etc
+    pisces_dir = project_root / ".pisces"
+    history_dir = pisces_dir / "history"
+    cache_dir = pisces_dir / "cache"
+    context_file = pisces_dir / "context.json"
+
+    # Creating the files
+    ok = all(
+        [
+            _create_dir(pisces_dir),
+            _create_dir(history_dir),
+            _create_dir(cache_dir),
+            _init_context_json(context_file, project_root, force=force),
+        ]
+    )
+    if not ok:
+        return 1  # error creating directories or context.json
+    # 4. .gitignore(means we are adding the .pisces in the .gitignore)
+    _update_gitignore(project_root)
+
+    # 5. Done
+    console.print()
+    print_success(
+        "✓  pisces initialized successfully!\n\n"
+        "  Next steps:\n"
+        "    1. [cyan]pisces config[/]   — set your LLM provider\n"
+        "    2. [cyan]pisces scan .[/]   — detect security vulnerabilities\n"
+        "    3. [cyan]pisces fix <finding>[/] — generate and apply a patch"
+    )
+
+    return 0  # successfully created
+
+
+"""Some Helper Functions"""
+
+
+def _init_pisces_toml(path: Path, *, force: bool) -> None:
+    existed = path.exists()
+    if existed and not force:
+        print_step_ok("pisces.toml already exists - skipping (use --force)")
+        return
+
+    action = "Overwriting" if existed else "creating"
+    print_step_running(f"{action} pisces.toml ...")
+    try:
+        path.write_text(_DEFAULT_PISCES_TOML, encoding="utf-8")
+        print_step_ok(f"pisces.toml {'overwritten' if existed else 'created'}")
+    except OSError as e:
+        print_step_fail(f"Could not write pisces.toml: {e}")
+
+
+def _create_dir(path: Path) -> None:
+    if path.exists():
+        print_step_ok(f"{path.name}/ already exists - skipping")
+        return True
+    try:
+        path.mkdir(parents=True, exist_ok=True)
+        print_step_ok(f"Created {path.name}/")
+        return True
+    except OSError as e:
+        print_step_fail(f"Could not create {path}: {e}")
+        return False
+
+
+def _init_context_json(path: Path, project_root: Path, *, force: bool) -> None:
+    if path.exists() and not force:
+        print_step_ok("context.json already exists - skipping")
+        return
+
+    print_step_running("Writing context.json ...")
+    try:
+        path.write_text(
+            json.dumps(_default_context(project_root), indent=2),
+            encoding="utf-8",
+        )
+        print_step_ok("context.json initialized")
+    except OSError as e:
+        print_step_fail(f"Could not write context.json: {e}")
+
+
+def _update_gitignore(project_root: Path) -> None:
+    """Ensure .pisces/ is listed in .gitignore."""
+    gitignore = project_root / ".gitignore"
+    entry = ".pisces/"
+
+    if not gitignore.exists():
+        print_step_running("No .ignore found - creating one ...")
+        try:
+            gitignore.write_text(f"# pisces state directory\n{entry}\n", encoding="utf-8")
+            print_step_ok(".gitignore created with .pisces/entry")
+        except OSError as e:
+            print_warning(f"could not create .gitignore: {e}")
+        return
+
+    content = gitignore.read_text(encoding="utf-8")
+    if entry in content or ".pisces" in content:
+        print_step_ok(".gitignore already contains .pisces entry - skipping")
+        return
+
+    try:
+        with gitignore.open("a", encoding="utf-8") as f:
+            f.write(f"\n# pisces state directory\n{entry}\n")
+        print_step_ok("Added .pisces/ to .gitignore")
+    except OSError as e:
+        print_warning(f"Could not update .gitignore: {e}")

pisces/judge.py

@@ -0,0 +1,131 @@
+"""
+pisces.judge
+~~~~~~~~~~~~
+LLM-based code review judge for proposed security patches.
+
+The judge acts as an adversarial reviewer:
+    "Does this patch CORRECTLY and COMPLETELY fix the vulnerability
+     without introducing new problems or changing unrelated behaviour?"
+
+Returns a structured JudgeResult the repair loop uses to decide
+whether to accept the patch, reject it, or ask for another attempt.
+"""
+
+from __future__ import annotations
+
+import re
+
+from pisces.llm_client import call_llm
+from pisces.models import Finding, JudgeResult, LLMRequest
+
+_JUDGE_SYSTEM = """\
+You are an adversarial security code reviewer. Your job is to judge
+whether a proposed patch correctly fixes a security vulnerability.
+Be strict. Reject patches that are incomplete, introduce new issues,
+or change behaviour unrelated to the vulnerability.
+
+Respond ONLY in this exact format:
+
+DECISION: APPROVED
+SECURITY_OK: true
+FUNCTIONALITY_OK: true
+SCOPE_OK: true
+REGRESSION_RISK: LOW
+PATCH_QUALITY: GOOD
+COMPLETENESS: COMPLETE
+REASONING: <one paragraph>
+
+Valid values:
+  DECISION:         APPROVED | REJECTED
+  SECURITY_OK:      true | false   (does it fix the vulnerability?)
+  FUNCTIONALITY_OK: true | false   (does it preserve intended behaviour?)
+  SCOPE_OK:         true | false   (does it change ONLY what's needed?)
+  REGRESSION_RISK:  LOW | MEDIUM | HIGH
+  PATCH_QUALITY:    GOOD | ACCEPTABLE | POOR
+  COMPLETENESS:     COMPLETE | PARTIAL | INCOMPLETE
+"""
+
+
+def judge_patch(
+    finding: Finding,
+    original_code: str,
+    patched_code: str,
+    provider: str,
+    model: str,
+    prior_failure: str | None = None,
+) -> JudgeResult:
+    """
+    Ask the LLM to judge whether *patched_code* correctly fixes *finding*.
+
+    *prior_failure* — if this is a re-attempt after test failure, include
+    the test output so the judge has extra context.
+    """
+    prior_section = ""
+    if prior_failure:
+        prior_section = f"""
+## Prior Attempt Failed
+The patch was applied and tests were run. The test suite FAILED with:
+{prior_failure[:1000]}
+
+Consider whether the patch caused this failure.
+"""
+    user_prompt = f"""\
+## Security Finding to Fix
+- Rule:     {finding.rule}
+- Severity: {finding.severity.value}
+- File:     {finding.file}
+- Line:     {finding.line}
+- Issue:    {finding.description}
+- Code:     `{finding.code}`
+---
+## Original Code (vulnerable)
+```python
+{original_code}
+Proposed Patch
+python
+{patched_code}
+{prior_section}
+Judge this patch. Is it correct, complete, and safe to apply? """
+
+    request = LLMRequest(
+        system_prompt=_JUDGE_SYSTEM,
+        user_prompt=user_prompt,
+        temperature=0.1,  # very low — we want consistent, strict judgment
+        max_tokens=512,
+    )
+    response = call_llm(request, provider=provider, model=model)
+    return _parse_judge_response(response.content)
+
+
+def _parse_judge_response(content: str) -> JudgeResult:
+    """Parse the structured judge response into a JudgeResult."""
+
+    def _field(name: str, default: str = "") -> str:
+        m = re.search(rf"^{name}:\s*(.+)$", content, re.MULTILINE | re.IGNORECASE)
+        return m.group(1).strip() if m else default
+
+    def _bool_field(name: str, default: bool = True) -> bool:
+        val = _field(name, "true").lower()
+        return val == "true"
+
+    decision = _field("DECISION", "REJECTED").upper()
+    security_ok = _bool_field("SECURITY_OK", False)
+    functionality_ok = _bool_field("FUNCTIONALITY_OK", True)
+    scope_ok = _bool_field("SCOPE_OK", True)
+    regression_risk = _field("REGRESSION_RISK", "MEDIUM").upper()
+    patch_quality = _field("PATCH_QUALITY", "ACCEPTABLE").upper()
+    completeness = _field("COMPLETENESS", "PARTIAL").upper()
+    reasoning = _field("REASONING", content[:300])
+    # Safety override: if security not fixed, decision must be REJECTED
+    if not security_ok:
+        decision = "REJECTED"
+    return JudgeResult(
+        decision=decision,
+        security_ok=security_ok,
+        functionality_ok=functionality_ok,
+        scope_ok=scope_ok,
+        regression_risk=regression_risk,
+        patch_quality=patch_quality,
+        completeness=completeness,
+        reasoning=reasoning,
+    )