scamscript 0.2.0__py3-none-any.whl

scamscript/render.py

@@ -0,0 +1,232 @@
+"""Rich rendering of breakdowns, prompts, and summaries."""
+
+from __future__ import annotations
+
+from rich.console import Group, RenderableType
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from scamscript.ingest import ScriptFile
+from scamscript.models import ScriptBreakdown
+from scamscript.verify import Issue, summarize
+
+SECTION_LABELS = {
+    "persona": "PERSONA",
+    "opening_hook": "OPENING HOOK",
+    "trust_building_moves": "TRUST BUILDING",
+    "urgency_tactics": "URGENCY TACTICS",
+    "escalation_ladder": "ESCALATION LADDER",
+    "target_demographics": "TARGET DEMOGRAPHICS",
+    "red_flags": "RED FLAGS",
+    "defense_summary": "DEFENSE SUMMARY",
+    "quote_check": "QUOTE CHECK",
+}
+
+SECTION_COLORS = {
+    "attack_type": "bold white on dark_red",
+    "persona": "magenta",
+    "opening_hook": "italic cyan",
+    "trust_building_moves": "yellow",
+    "urgency_tactics": "bold orange3",
+    "escalation_ladder": "dark_orange3",
+    "target_demographics": "blue",
+    "red_flags": "bold red",
+    "defense_summary": "bold green",
+    "quote_check": "dim white",
+}
+
+MARKERS = {
+    "trust_building_moves": "•",
+    "urgency_tactics": "!",
+    "escalation_ladder": "→",
+    "red_flags": "✗",
+}
+
+ATTACK_COLORS = {
+    "vishing": "red",
+    "smishing": "magenta",
+    "romance": "bright_magenta",
+    "tech support": "blue",
+    "government": "bright_red",
+    "refund": "orange3",
+    "crypto": "yellow",
+}
+
+
+def border_for(breakdown: ScriptBreakdown) -> str:
+    score = breakdown.sophistication_score
+    if score >= 8:
+        return "red"
+    if score >= 5:
+        return "yellow"
+    return "green"
+
+
+def attack_color(attack_type: str) -> str:
+    lowered = attack_type.lower()
+    for needle, color in ATTACK_COLORS.items():
+        if needle in lowered:
+            return color
+    return "red"
+
+
+def _heading(breakdown_key: str) -> Text:
+    return Text(SECTION_LABELS[breakdown_key], style=SECTION_COLORS[breakdown_key])
+
+
+def _items(values: list[str], marker: str, color: str) -> Text:
+    body = Text()
+    for index, value in enumerate(values, start=1):
+        prefix = f"{index}." if marker == "→" else marker
+        body.append(f"  {prefix} ", style=f"bold {color}")
+        body.append(value)
+        if index < len(values):
+            body.append("\n")
+    return body
+
+
+def _section(key: str, breakdown: ScriptBreakdown) -> list[RenderableType]:
+    value = getattr(breakdown, key)
+    parts: list[RenderableType] = [_heading(key)]
+    if isinstance(value, list):
+        if not value:
+            parts.append(Text("  (none recorded)", style="dim"))
+        else:
+            parts.append(_items(value, MARKERS[key], SECTION_COLORS[key]))
+    else:
+        style = "italic" if key == "opening_hook" else ""
+        parts.append(Text(f"  {value}", style=style))
+    parts.append(Text(""))
+    return parts
+
+
+def render_breakdown(
+    breakdown: ScriptBreakdown,
+    name: str,
+    attempts: int = 1,
+    issues: list[Issue] | None = None,
+) -> Panel:
+    renderables: list[RenderableType] = []
+
+    attack = Text()
+    attack.append("ATTACK TYPE  ", style="dim")
+    attack.append(
+        f" {breakdown.attack_type.upper()} ",
+        style=SECTION_COLORS["attack_type"],
+    )
+    attack.append("   ")
+    attack.append("SOPHISTICATION  ", style="dim")
+    attack.append(
+        f"{breakdown.sophistication_score}/10",
+        style=f"bold {border_for(breakdown)}",
+    )
+    renderables.append(attack)
+    renderables.append(Text(""))
+
+    for key in (
+        "persona",
+        "opening_hook",
+        "trust_building_moves",
+        "urgency_tactics",
+        "escalation_ladder",
+        "target_demographics",
+        "red_flags",
+    ):
+        renderables.extend(_section(key, breakdown))
+
+    if issues is not None:
+        renderables.extend(_quote_section(issues))
+
+    renderables.extend(_section("defense_summary", breakdown))
+
+    subtitle_parts = [f"{breakdown.flag_count} red flags"]
+    counts = summarize(issues or [])
+    if counts["checked"]:
+        subtitle_parts.append(f"{counts['verbatim']}/{counts['checked']} quotes verbatim")
+        if counts["missing"]:
+            subtitle_parts.append(f"{counts['missing']} missing")
+    if attempts > 1:
+        subtitle_parts.append(f"repaired on attempt {attempts}")
+    subtitle = " · ".join(subtitle_parts)
+
+    return Panel(
+        Group(*renderables),
+        title=f"[bold]{name}[/bold]",
+        subtitle=f"[dim]{subtitle}[/dim]",
+        border_style=border_for(breakdown),
+        padding=(0, 1),
+    )
+
+
+def _quote_section(issues: list[Issue]) -> list[RenderableType]:
+    parts: list[RenderableType] = [_heading("quote_check")]
+    bad = [issue for issue in issues if not issue.ok]
+    if not issues:
+        parts.append(Text("  (no quoted claims to check)", style="dim"))
+    elif not bad:
+        parts.append(Text("  all quoted claims found in the source", style="green"))
+    else:
+        body = Text()
+        for index, issue in enumerate(bad, start=1):
+            marker = "≈" if issue.status == "close" else "✗"
+            style = "yellow" if issue.status == "close" else "red"
+            body.append(f"  {marker} ", style=f"bold {style}")
+            body.append(f"{issue.field}: ", style="dim")
+            body.append(issue.quote, style=style)
+            if index < len(bad):
+                body.append("\n")
+        parts.append(body)
+    parts.append(Text(""))
+    return parts
+
+
+def render_failure(name: str, error: str, attempts: int) -> Panel:
+    body = Text()
+    body.append("FAILED after ", style="bold red")
+    body.append(f"{attempts} attempt(s)\n\n")
+    body.append(error, style="red")
+    return Panel(body, title=f"[bold]{name}[/bold]", border_style="red", padding=(0, 1))
+
+
+def render_prompt(source: ScriptFile, messages: list[dict[str, str]]) -> Panel:
+    body = Text()
+    for message in messages:
+        body.append(f"<{message['role']}>\n", style="bold cyan")
+        body.append(message["content"] + "\n\n", style="")
+    header = Text(
+        f"{len(messages)} message(s) · {sum(len(m['content']) for m in messages)} chars",
+        style="dim",
+    )
+    return Panel(
+        Group(header, Text(""), body),
+        title=f"[bold]dry run: {source.name}[/bold]",
+        border_style="cyan",
+        padding=(0, 1),
+    )
+
+
+def render_summary_table(rows: list[tuple[str, ScriptBreakdown | None, str | None]]) -> Table:
+    table = Table(title="Run summary", header_style="bold", expand=True)
+    table.add_column("Script", overflow="fold", ratio=3)
+    table.add_column("Attack type", ratio=2)
+    table.add_column("Score", justify="right")
+    table.add_column("Flags", justify="right")
+    table.add_column("Status")
+    for name, breakdown, error in rows:
+        if breakdown is None:
+            table.add_row(name, "-", "-", "-", f"[red]{error or 'failed'}[/red]")
+            continue
+        table.add_row(
+            name,
+            f"[{attack_color(breakdown.attack_type)}]{breakdown.attack_type}[/]",
+            f"{breakdown.sophistication_score}/10",
+            str(breakdown.flag_count),
+            "[green]ok[/green]",
+        )
+    return table
+
+
+def render_report(markdown: str) -> Markdown:
+    return Markdown(markdown, hyperlinks=True)

scamscript/report.py

@@ -0,0 +1,196 @@
+"""Aggregated markdown reporting, live or replayed from logs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import ValidationError
+
+from scamscript.models import ScriptBreakdown
+from scamscript.store import results_of, utc_now
+
+SECTIONS = (
+    ("persona", "Persona adopted"),
+    ("opening_hook", "Opening hook"),
+    ("trust_building_moves", "Trust-building moves"),
+    ("urgency_tactics", "Urgency tactics"),
+    ("escalation_ladder", "Escalation ladder"),
+    ("target_demographics", "Target demographics"),
+    ("red_flags", "Red flags"),
+    ("defense_summary", "Defense summary"),
+)
+
+
+@dataclass(slots=True)
+class ReportEntry:
+    name: str
+    source: str
+    breakdown: ScriptBreakdown | None = None
+    error: str | None = None
+    duration: float = 0.0
+    verification: dict[str, int] | None = None
+    unverified: list[dict[str, str]] | None = None
+
+    @property
+    def ok(self) -> bool:
+        return self.breakdown is not None
+
+
+def entry_from_outcome(outcome: Any) -> ReportEntry:
+    return ReportEntry(
+        name=outcome.name,
+        source=str(getattr(outcome, "source", outcome.name)),
+        breakdown=outcome.breakdown,
+        error=outcome.error,
+        duration=getattr(outcome, "duration", 0.0),
+        verification=getattr(outcome, "verification", None),
+        unverified=[
+            {"field": issue.field, "quote": issue.quote, "status": issue.status}
+            for issue in getattr(outcome, "issues", None) or []
+            if not issue.ok
+        ],
+    )
+
+
+def entries_from_run(run: dict[str, Any]) -> list[ReportEntry]:
+    entries: list[ReportEntry] = []
+    for record in results_of(run):
+        payload = record.get("breakdown")
+        breakdown: ScriptBreakdown | None = None
+        if isinstance(payload, dict):
+            try:
+                breakdown = ScriptBreakdown.model_validate(payload)
+            except ValidationError:
+                breakdown = None
+        entries.append(
+            ReportEntry(
+                name=record.get("name") or record.get("source") or "unknown",
+                source=record.get("source") or "",
+                breakdown=breakdown,
+                error=None if breakdown else record.get("error") or "no breakdown stored",
+                duration=float(record.get("duration_s") or 0.0),
+                verification=record.get("verification") or None,
+                unverified=record.get("unverified") or None,
+            )
+        )
+    return entries
+
+
+def rank(entries: list[ReportEntry]) -> list[ReportEntry]:
+    return sorted(
+        entries,
+        key=lambda entry: (
+            -(entry.breakdown.sophistication_score if entry.breakdown else -1),
+            -(entry.breakdown.flag_count if entry.breakdown else 0),
+            entry.name.lower(),
+        ),
+    )
+
+
+def build_markdown(
+    entries: list[ReportEntry],
+    run_id: str,
+    command: str = "batch",
+    model: str | None = None,
+) -> str:
+    ranked = rank(entries)
+    ok = [entry for entry in ranked if entry.ok]
+    failed = [entry for entry in ranked if not entry.ok]
+    average = (
+        sum(entry.breakdown.sophistication_score for entry in ok) / len(ok) if ok else 0.0
+    )
+
+    lines: list[str] = []
+    lines.append("# Scam script breakdown report")
+    lines.append("")
+    lines.append(f"- Generated: {utc_now()}")
+    lines.append(f"- Run: `{run_id}`")
+    lines.append(f"- Command: `{command}`")
+    if model:
+        lines.append(f"- Model: `{model}`")
+    lines.append(f"- Scripts analyzed: {len(entries)}")
+    lines.append(f"- Successful: {len(ok)}")
+    lines.append(f"- Failed: {len(failed)}")
+    unverified_total = sum(len(entry.unverified or []) for entry in ok)
+    if unverified_total:
+        lines.append(f"- Unverified quotes: {unverified_total}")
+    if ok:
+        lines.append(f"- Mean sophistication: {average:.1f}/10")
+    lines.append("")
+
+    if ok:
+        lines.append("## Ranking by sophistication")
+        lines.append("")
+        lines.append("| Rank | Script | Attack type | Sophistication | Red flags | Unverified |")
+        lines.append("| ---: | --- | --- | ---: | ---: | ---: |")
+        for position, entry in enumerate(ok, start=1):
+            lines.append(
+                f"| {position} | {_cell(entry.name)} | {_cell(entry.breakdown.attack_type)} | "
+                f"{entry.breakdown.sophistication_score}/10 | {entry.breakdown.flag_count} | "
+                f"{len(entry.unverified or [])} |"
+            )
+        lines.append("")
+        for position, entry in enumerate(ok, start=1):
+            lines.extend(_detail_section(position, entry))
+    else:
+        lines.append("_No successful analyses in this run._")
+        lines.append("")
+
+    if failed:
+        lines.append("## Failures")
+        lines.append("")
+        for entry in failed:
+            lines.append(f"- **{_cell(entry.name)}** (`{_cell(entry.source)}`): {_cell(entry.error or 'unknown error')}")
+        lines.append("")
+
+    lines.append("---")
+    lines.append("")
+    lines.append(
+        "_Generated by scamscript for security research and fraud-awareness training only. "
+        "Breakdowns are model-produced readings of captured scripts, not legal advice._"
+    )
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _detail_section(position: int, entry: ReportEntry) -> list[str]:
+    breakdown = entry.breakdown
+    assert breakdown is not None
+    lines = [f"## {position}. {entry.name}", ""]
+    lines.append(f"- **Attack type:** {breakdown.attack_type}")
+    lines.append(f"- **Sophistication:** {breakdown.sophistication_score}/10")
+    lines.append(f"- **Red flags observed:** {breakdown.flag_count}")
+    counts = entry.verification or {}
+    if counts.get("checked"):
+        lines.append(
+            f"- **Quote check:** {counts.get('verbatim', 0)}/{counts['checked']} verbatim, "
+            f"{counts.get('missing', 0)} missing"
+        )
+    if entry.source:
+        lines.append(f"- **Source:** `{entry.source}`")
+    lines.append("")
+    if entry.unverified:
+        lines.append("### Unverified quotes")
+        lines.append("")
+        for item in entry.unverified:
+            mark = "close" if item.get("status") == "close" else "missing"
+            lines.append(f"- _{mark}_ [{(item.get('field') or '').replace('_', ' ')}] \"{item.get('quote', '')}\"")
+        lines.append("")
+    for field, label in SECTIONS:
+        value = getattr(breakdown, field)
+        lines.append(f"### {label}")
+        lines.append("")
+        if isinstance(value, list):
+            if value:
+                lines.extend(f"{index}. {item}" for index, item in enumerate(value, start=1))
+            else:
+                lines.append("_None recorded._")
+        else:
+            lines.append(value or "_None recorded._")
+        lines.append("")
+    return lines
+
+
+def _cell(value: str) -> str:
+    return (value or "").replace("|", "\\|").replace("\n", " ").strip()

scamscript/store.py

@@ -0,0 +1,187 @@
+"""Append-only JSONL request log under the scamscript home."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+RUN_ID_LENGTH = 12
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def new_run_id() -> str:
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return f"{stamp}-{uuid.uuid4().hex[:RUN_ID_LENGTH]}"
+
+
+class RunLogger:
+    """Writes one JSONL file per run; never raises on log failure."""
+
+    def __init__(self, logs_dir: str, command: str, run_id: str | None = None) -> None:
+        self.run_id = run_id or new_run_id()
+        self.logs_dir = Path(logs_dir)
+        self.command = command
+        self.path = self.logs_dir / f"{self.run_id}.jsonl"
+        self._started = False
+
+    def _write(self, record: dict[str, Any]) -> None:
+        record.setdefault("ts", utc_now())
+        record.setdefault("run_id", self.run_id)
+        try:
+            self.logs_dir.mkdir(parents=True, exist_ok=True)
+            with self.path.open("a", encoding="utf-8") as handle:
+                handle.write(json.dumps(record, ensure_ascii=False) + "\n")
+        except OSError:
+            pass
+
+    def run_start(self, **fields: Any) -> None:
+        if self._started:
+            return
+        self._started = True
+        self._write({"event": "run_start", "command": self.command, **fields})
+
+    def request(self, **fields: Any) -> None:
+        self._write({"event": "request", **fields})
+
+    def result(self, **fields: Any) -> None:
+        self._write({"event": "result", **fields})
+
+    def error(self, **fields: Any) -> None:
+        self._write({"event": "error", **fields})
+
+    def run_end(self, **fields: Any) -> None:
+        self._write({"event": "run_end", **fields})
+
+
+def read_records(path: Path) -> list[dict[str, Any]]:
+    records: list[dict[str, Any]] = []
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return records
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            record = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(record, dict):
+            records.append(record)
+    return records
+
+
+def discover_runs(logs_dir: str) -> list[dict[str, Any]]:
+    """Summarize every run file, newest first."""
+    directory = Path(logs_dir).expanduser()
+    if not directory.is_dir():
+        return []
+    runs: list[dict[str, Any]] = []
+    for path in sorted(directory.glob("*.jsonl"), key=_mtime, reverse=True):
+        records = read_records(path)
+        if not records:
+            continue
+        runs.append(summarize_run(path, records))
+    return runs
+
+
+def summarize_run(path: Path, records: list[dict[str, Any]]) -> dict[str, Any]:
+    start = _first(records, "run_start")
+    end = _first(records, "run_end")
+    results = [r for r in records if r.get("event") == "result"]
+    errors = [r for r in records if r.get("event") == "error"]
+    sources = [r.get("source") for r in results + errors if r.get("source")]
+    return {
+        "run_id": start.get("run_id") if start else path.stem,
+        "path": str(path),
+        "command": start.get("command", "unknown") if start else "unknown",
+        "started": start.get("ts") if start else None,
+        "finished": end.get("ts") if end else None,
+        "status": (end or {}).get("status", "incomplete"),
+        "results": len(results),
+        "failures": len(errors),
+        "sources": sources,
+        "dry_run": bool(start.get("dry_run")) if start else False,
+        "model": (start or {}).get("model"),
+        "base_url": (start or {}).get("base_url"),
+        "records": records,
+    }
+
+
+def load_run(logs_dir: str, run_id: str) -> dict[str, Any] | None:
+    path = Path(logs_dir).expanduser() / f"{run_id}.jsonl"
+    if not path.is_file():
+        return None
+    records = read_records(path)
+    if not records:
+        return None
+    return summarize_run(path, records)
+
+
+def results_of(run: dict[str, Any]) -> list[dict[str, Any]]:
+    return [r for r in run.get("records", []) if r.get("event") == "result"]
+
+
+def _first(records: list[dict[str, Any]], event: str) -> dict[str, Any] | None:
+    for record in records:
+        if record.get("event") == event:
+            return record
+    return None
+
+
+def _mtime(path: Path) -> float:
+    try:
+        return path.stat().st_mtime
+    except OSError:
+        return 0.0
+
+
+def ensure_home(home: str) -> None:
+    try:
+        os.makedirs(os.path.join(home, "logs"), exist_ok=True)
+    except OSError:
+        pass
+
+
+def prune(
+    logs_dir: str,
+    keep_days: int | None = 30,
+    keep: int | None = 200,
+) -> tuple[int, int, int]:
+    """Delete old run logs. Returns (deleted, bytes_freed, kept)."""
+    directory = Path(logs_dir).expanduser()
+    if not directory.is_dir():
+        return 0, 0, 0
+    now = time.time()
+    files = sorted(
+        (path for path in directory.glob("*.jsonl") if path.is_file()),
+        key=_mtime,
+        reverse=True,
+    )
+    deleted = 0
+    freed = 0
+    kept = 0
+    for index, path in enumerate(files):
+        too_many = keep is not None and index >= keep
+        stale = keep_days is not None and (now - _mtime(path)) > keep_days * 86400
+        if not too_many and not stale:
+            kept += 1
+            continue
+        try:
+            size = path.stat().st_size
+            path.unlink()
+        except OSError:
+            kept += 1
+            continue
+        deleted += 1
+        freed += size
+    return deleted, freed, kept