scamscript 0.3.0__tar.gz → 0.4.0__tar.gz

{scamscript-0.3.0 → scamscript-0.4.0}/CHANGELOG.md

@@ -5,6 +5,19 @@ schema are the things that count as public API.
 
 ## Unreleased
 
+## 0.4.0 - 2026-11-02
+
+### Added
+
+- `--concurrency N` (1-16) with order-preserving output.
+- `--max-cost USD`: stop scheduling once reported spend reaches the cap, mark the rest skipped, and
+  warn when a provider reports no cost.
+- Per-run reported spend in output and logs.
+
+### Changed
+
+- Token usage is tracked per thread so parallel calls cannot read each other's cost.
+
 ## 0.3.0 - 2026-11-02
 
 ### Changed

{scamscript-0.3.0 → scamscript-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scamscript
-Version: 0.3.0
+Version: 0.4.0
 Summary: Reverse-engineer scam scripts and vishing transcripts into structured counter-playbooks
 Project-URL: Homepage, https://github.com/sjdsjadjajdjsa/scamscript
 Project-URL: Repository, https://github.com/sjdsjadjajdjsa/scamscript
@@ -133,7 +133,7 @@ corpus is at [`docs/sample-report.md`](https://github.com/sjdsjadjajdjsa/scamscr
 | `prune` | Delete old logs |
 
 Useful flags: `--dry-run`, `--json`, `--redact`, `--top N`, `--recursive`, `--timeout`,
-`--retries`, `--max-tokens`, `--no-color`. `--json` puts one object per script on stdout and all
+`--retries`, `--max-tokens`, `--concurrency`, `--max-cost`, `--no-color`. `--json` puts one object per script on stdout and all
 Rich output on stderr, so it pipes:
 
 ```bash
@@ -249,6 +249,7 @@ docs/           calibration record, sample report, banner, demo
   `opening_hook` and `red_flags` against the source before quoting anything.
 - Redaction is regex-based and will miss names and identifiers without a fixed shape.
 - One script per request; no cross-script deduplication yet, so reprints inflate a ranking.
+- The cost cap depends on provider-reported usage and can overshoot by the in-flight count.
 - Analysis is English-centric: the prompt and schema assume English artifacts.
 - Quote checking compares text, not meaning. A legitimate paraphrase left in quotes is flagged;
   an accurate paraphrase without quotes is skipped rather than judged.

{scamscript-0.3.0 → scamscript-0.4.0}/README.md

@@ -97,7 +97,7 @@ corpus is at [`docs/sample-report.md`](https://github.com/sjdsjadjajdjsa/scamscr
 | `prune` | Delete old logs |
 
 Useful flags: `--dry-run`, `--json`, `--redact`, `--top N`, `--recursive`, `--timeout`,
-`--retries`, `--max-tokens`, `--no-color`. `--json` puts one object per script on stdout and all
+`--retries`, `--max-tokens`, `--concurrency`, `--max-cost`, `--no-color`. `--json` puts one object per script on stdout and all
 Rich output on stderr, so it pipes:
 
 ```bash
@@ -213,6 +213,7 @@ docs/           calibration record, sample report, banner, demo
   `opening_hook` and `red_flags` against the source before quoting anything.
 - Redaction is regex-based and will miss names and identifiers without a fixed shape.
 - One script per request; no cross-script deduplication yet, so reprints inflate a ranking.
+- The cost cap depends on provider-reported usage and can overshoot by the in-flight count.
 - Analysis is English-centric: the prompt and schema assume English artifacts.
 - Quote checking compares text, not meaning. A legitimate paraphrase left in quotes is flagged;
   an accurate paraphrase without quotes is skipped rather than judged.

{scamscript-0.3.0 → scamscript-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "scamscript"
-version = "0.3.0"
+version = "0.4.0"
 description = "Reverse-engineer scam scripts and vishing transcripts into structured counter-playbooks"
 readme = "README.md"
 requires-python = ">=3.12"

{scamscript-0.3.0 → scamscript-0.4.0}/src/scamscript/__init__.py

@@ -1,3 +1,3 @@
 """scamscript: reverse-engineering analyzer for scam call scripts."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{scamscript-0.3.0 → scamscript-0.4.0}/src/scamscript/analysis.py

@@ -26,6 +26,7 @@ class Outcome:
     error: str | None = None
     duration: float = 0.0
     redactions: dict[str, int] | None = None
+    skipped: bool = False
     issues: list[verify.Issue] | None = None
     verification: dict[str, int] | None = None
 
@@ -39,6 +40,7 @@ class Outcome:
             "source": str(self.source),
             "name": self.name,
             "ok": self.ok,
+            "skipped": self.skipped,
             "attempts": self.attempts,
             "duration_s": round(self.duration, 3),
             "breakdown": self.breakdown.model_dump() if self.breakdown else None,

{scamscript-0.3.0 → scamscript-0.4.0}/src/scamscript/cli.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import json
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -104,6 +106,20 @@ def main(
         min=256,
         help="Output token budget per reply.",
     ),
+    concurrency: int = typer.Option(
+        1,
+        "--concurrency",
+        "-j",
+        min=1,
+        max=16,
+        help="Analyze this many scripts in parallel.",
+    ),
+    max_cost: float | None = typer.Option(
+        None,
+        "--max-cost",
+        min=0.0,
+        help="Stop scheduling new scripts once the provider reports this much spend in USD.",
+    ),
     redact: bool = typer.Option(
         False,
         "--redact",
@@ -146,6 +162,8 @@ def main(
         timeout=timeout,
         retries=retries,
         max_tokens=max_tokens,
+        concurrency=concurrency,
+        max_cost=max_cost,
         redact=redact,
         home=str(home) if home else "",
     )
@@ -254,8 +272,12 @@ def _run(
         _fail(console, str(exc))
         return
 
-    outcomes: list[Outcome] = []
+    outcomes: list[Outcome | None] = [None] * len(scripts)
     report_entries: list[reporting.ReportEntry] = []
+    budget = settings.max_cost
+    spent = 0.0
+    spent_seen = False
+    lock = threading.Lock()
     client = ChatClient(
         api_key=api_key,
         base_url=settings.base_url,
@@ -264,50 +286,114 @@ def _run(
         retries=settings.retries,
         max_tokens=settings.max_tokens,
     )
-    with client:
-        for index, script in enumerate(scripts, start=1):
-            if batch_mode and not state.json_output:
-                console.print(
-                    f"[dim]({index}/{len(scripts)}) analyzing {script.name}...[/dim]"
+
+    def one(script: ScriptFile) -> Outcome:
+        nonlocal spent, spent_seen
+        if budget is not None:
+            with lock:
+                blocked = spent >= budget
+            if blocked:
+                outcome = Outcome(
+                    source=script.path,
+                    name=script.name,
+                    skipped=True,
+                    error="skipped: cost budget reached",
+                )
+                logger.result(**outcome.as_record())
+                return outcome
+        outcome = analyze_script(
+            client,
+            script,
+            logger,
+            redact_identifiers=settings.redact,
+            verify_quotes=state.verify_quotes,
+        )
+        cost = client.last_cost
+        if cost:
+            with lock:
+                spent += cost
+                spent_seen = True
+        return outcome
+
+    def emit(outcome: Outcome) -> None:
+        if state.json_output:
+            _emit_json(outcome.as_record())
+        elif outcome.skipped:
+            console.print(f"[dim]skipped {outcome.name}: budget reached[/dim]")
+        elif outcome.breakdown is not None:
+            console.print(
+                render_breakdown(
+                    outcome.breakdown, outcome.name, outcome.attempts, outcome.issues
                 )
-            outcome = analyze_script(
-                client,
-                script,
-                logger,
-                redact_identifiers=settings.redact,
-                verify_quotes=state.verify_quotes,
             )
-            outcomes.append(outcome)
-            report_entries.append(reporting.entry_from_outcome(outcome))
-            if state.json_output:
-                _emit_json(outcome.as_record())
-            elif outcome.breakdown is not None:
-                console.print(
-                    render_breakdown(
-                        outcome.breakdown,
-                        outcome.name,
-                        outcome.attempts,
-                        outcome.issues,
+        else:
+            console.print(
+                render_failure(outcome.name, outcome.error or "unknown", outcome.attempts)
+            )
+
+    with client:
+        if settings.concurrency == 1:
+            for index, script in enumerate(scripts, start=1):
+                if batch_mode and not state.json_output:
+                    console.print(
+                        f"[dim]({index}/{len(scripts)}) analyzing {script.name}...[/dim]"
                     )
-                )
-            else:
+                outcome = one(script)
+                outcomes[index - 1] = outcome
+                report_entries.append(reporting.entry_from_outcome(outcome))
+                emit(outcome)
+        else:
+            if not state.json_output:
                 console.print(
-                    render_failure(outcome.name, outcome.error or "unknown", outcome.attempts)
+                    f"[dim]analyzing {len(scripts)} script(s), "
+                    f"{settings.concurrency} at a time[/dim]"
                 )
-
-    successes = sum(1 for outcome in outcomes if outcome.ok)
-    failures = len(outcomes) - successes
+            buffered: dict[int, Outcome] = {}
+            ready = 0
+            with ThreadPoolExecutor(max_workers=settings.concurrency) as pool:
+                futures = {
+                    pool.submit(one, script): index for index, script in enumerate(scripts)
+                }
+                for future in as_completed(futures):
+                    buffered[futures[future]] = future.result()
+                    while ready in buffered:
+                        outcome = buffered.pop(ready)
+                        outcomes[ready] = outcome
+                        report_entries.append(reporting.entry_from_outcome(outcome))
+                        emit(outcome)
+                        ready += 1
+
+    finished = [outcome for outcome in outcomes if outcome is not None]
+    successes = sum(1 for outcome in finished if outcome.ok)
+    skipped = sum(1 for outcome in finished if outcome.skipped)
+    failures = len(finished) - successes - skipped
+    if budget is not None and not spent_seen:
+        console.print(
+            "[yellow]note[/yellow] the endpoint reported no cost; --max-cost could not be enforced"
+        )
+    if skipped:
+        console.print(f"[yellow]{skipped} script(s) skipped at the cost budget[/yellow]")
+    if spent:
+        console.print(f"[dim]reported spend: ${spent:.4f}[/dim]")
     unverified = sum(
-        1 for outcome in outcomes for issue in (outcome.issues or []) if not issue.ok
+        1 for outcome in finished for issue in (outcome.issues or []) if not issue.ok
     )
     if state.strict_quotes and unverified:
         failures += 0
-    logger.run_end(status="ok" if failures == 0 else "partial", results=successes, failures=failures)
+    logger.run_end(
+        status="ok" if failures == 0 else "partial",
+        results=successes,
+        failures=failures,
+        skipped=skipped,
+        cost_usd=round(spent, 6),
+    )
 
-    if batch_mode and successes:
+    if batch_mode and (successes or skipped):
         if not state.json_output:
             console.print(
-                render_summary_table([(o.name, o.breakdown, o.error) for o in outcomes])
+                render_summary_table(
+                    [(o.name, o.breakdown, o.error, o.skipped) for o in finished]
+                )
             )
         ranked = reporting.rank(report_entries)
         if top:

{scamscript-0.3.0 → scamscript-0.4.0}/src/scamscript/client.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import threading
 import time
 from typing import Any, Callable
 
@@ -52,7 +53,7 @@ class ChatClient:
         self.model = model
         self.retries = max(0, retries)
         self.max_tokens = max_tokens
-        self.last_usage: dict[str, int] | None = None
+        self._usage = threading.local()
         self._sleep = sleep
         self._client = httpx.Client(
             base_url=self.base_url,
@@ -62,7 +63,7 @@ class ChatClient:
                 "Authorization": f"Bearer {api_key}",
                 "Content-Type": "application/json",
                 "Accept": "application/json",
-                "User-Agent": "scamscript/0.3.0",
+                "User-Agent": "scamscript/0.4.0",
             },
         )
 
@@ -75,6 +76,24 @@ class ChatClient:
     def close(self) -> None:
         self._client.close()
 
+    @property
+    def last_usage(self) -> dict[str, int] | None:
+        return getattr(self._usage, "value", None)
+
+    @last_usage.setter
+    def last_usage(self, value: dict[str, int] | None) -> None:
+        self._usage.value = value
+
+    @property
+    def last_cost(self) -> float | None:
+        usage = self.last_usage
+        if not usage:
+            return None
+        try:
+            return float(usage.get("cost") or 0.0)
+        except (TypeError, ValueError):
+            return None
+
     @property
     def endpoint(self) -> str:
         return f"{self.base_url}/chat/completions"

{scamscript-0.3.0 → scamscript-0.4.0}/src/scamscript/config.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass, field
 
 DEFAULT_TIMEOUT = 120.0
 DEFAULT_RETRIES = 2
+DEFAULT_CONCURRENCY = 1
 DEFAULT_MAX_TOKENS = 4096
 ENV_API_KEY = "API_KEY"
 ENV_HOME = "SCAMSCRIPT_HOME"
@@ -25,11 +26,16 @@ class Settings:
     retries: int = DEFAULT_RETRIES
     max_tokens: int = DEFAULT_MAX_TOKENS
     redact: bool = False
+    concurrency: int = DEFAULT_CONCURRENCY
+    max_cost: float | None = None
     home: str = field(default_factory=lambda: os.environ.get(ENV_HOME, ""))
 
     def __post_init__(self) -> None:
         self.base_url = (self.base_url or "").strip().rstrip("/")
         self.model = (self.model or "").strip()
+        self.concurrency = max(1, min(16, self.concurrency))
+        if self.max_cost is not None:
+            self.max_cost = max(0.0, self.max_cost)
         home = self.home or os.path.join(os.path.expanduser("~"), ".scamscript")
         self.home = home
 

{scamscript-0.3.0 → scamscript-0.4.0}/src/scamscript/render.py

@@ -207,14 +207,19 @@ def render_prompt(source: ScriptFile, messages: list[dict[str, str]]) -> Panel:
     )
 
 
-def render_summary_table(rows: list[tuple[str, ScriptBreakdown | None, str | None]]) -> Table:
+def render_summary_table(
+    rows: list[tuple[str, ScriptBreakdown | None, str | None, bool]]
+) -> 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:
+    for name, breakdown, error, skipped in rows:
+        if skipped:
+            table.add_row(name, "-", "-", "-", "[yellow]skipped[/yellow]")
+            continue
         if breakdown is None:
             table.add_row(name, "-", "-", "-", f"[red]{error or 'failed'}[/red]")
             continue

{scamscript-0.3.0 → scamscript-0.4.0}/src/scamscript/report.py

@@ -29,6 +29,7 @@ class ReportEntry:
     breakdown: ScriptBreakdown | None = None
     error: str | None = None
     duration: float = 0.0
+    skipped: bool = False
     verification: dict[str, int] | None = None
     unverified: list[dict[str, str]] | None = None
 
@@ -42,6 +43,7 @@ def entry_from_outcome(outcome: Any) -> ReportEntry:
         name=outcome.name,
         source=str(getattr(outcome, "source", outcome.name)),
         breakdown=outcome.breakdown,
+        skipped=getattr(outcome, "skipped", False),
         error=outcome.error,
         duration=getattr(outcome, "duration", 0.0),
         verification=getattr(outcome, "verification", None),
@@ -68,6 +70,7 @@ def entries_from_run(run: dict[str, Any]) -> list[ReportEntry]:
                 name=record.get("name") or record.get("source") or "unknown",
                 source=record.get("source") or "",
                 breakdown=breakdown,
+                skipped=bool(record.get("skipped")),
                 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,
@@ -96,7 +99,8 @@ def build_markdown(
 ) -> str:
     ranked = rank(entries)
     ok = [entry for entry in ranked if entry.ok]
-    failed = [entry for entry in ranked if not entry.ok]
+    skipped = [entry for entry in ranked if entry.skipped and not entry.ok]
+    failed = [entry for entry in ranked if not entry.ok and not entry.skipped]
     average = (
         sum(entry.breakdown.sophistication_score for entry in ok) / len(ok) if ok else 0.0
     )
@@ -112,6 +116,8 @@ def build_markdown(
     lines.append(f"- Scripts analyzed: {len(entries)}")
     lines.append(f"- Successful: {len(ok)}")
     lines.append(f"- Failed: {len(failed)}")
+    if skipped:
+        lines.append(f"- Skipped at budget: {len(skipped)}")
     unverified_total = sum(len(entry.unverified or []) for entry in ok)
     if unverified_total:
         lines.append(f"- Unverified quotes: {unverified_total}")
@@ -137,6 +143,13 @@ def build_markdown(
         lines.append("_No successful analyses in this run._")
         lines.append("")
 
+    if skipped:
+        lines.append("## Skipped")
+        lines.append("")
+        for entry in skipped:
+            lines.append(f"- **{_cell(entry.name)}** (`{_cell(entry.source)}`)")
+        lines.append("")
+
     if failed:
         lines.append("## Failures")
         lines.append("")

{scamscript-0.3.0 → scamscript-0.4.0}/tests/test_cli.py

@@ -32,6 +32,7 @@ class FakeClient:
         self.base_url = base_url
         self.model = model
         self.max_tokens = kwargs.get("max_tokens", 4096)
+        self.last_cost = None
 
     def __enter__(self):
         return self
@@ -227,7 +228,7 @@ def test_dry_run_without_endpoint(home, tmp_path, monkeypatch):
 def test_version(home):
     result = runner.invoke(cli.app, ["--version"])
     assert result.exit_code == 0
-    assert result.stdout.strip() == "scamscript 0.3.0"
+    assert result.stdout.strip() == "scamscript 0.4.0"
 
 
 def test_json_output_is_one_object_per_script(home, tmp_path, fake):
@@ -341,3 +342,70 @@ def test_json_result_carries_verification(home, tmp_path, fake):
     record = json.loads(result.stdout.splitlines()[0])
     assert record["verification"] == {"checked": 1, "verbatim": 0, "close": 0, "missing": 1}
     assert record["unverified"][0]["status"] == "missing"
+
+
+def test_concurrency_keeps_output_order(home, tmp_path, fake):
+    for index in range(6):
+        (tmp_path / f"s{index}.txt").write_text(f"CALLER: script {index}", encoding="utf-8")
+    result = runner.invoke(
+        cli.app, ["--api-key", "k", "--json", "--concurrency", "4", "batch", str(tmp_path)]
+    )
+    assert result.exit_code == 0
+    records = [json.loads(line) for line in result.stdout.splitlines() if line.strip()]
+    names = [record["name"] for record in records if "name" in record]
+    assert names[:6] == [f"s{i}.txt" for i in range(6)]
+
+
+def test_concurrency_runs_in_parallel(home, tmp_path, fake, monkeypatch):
+    import threading, time
+
+    active = {"now": 0, "peak": 0}
+    lock = threading.Lock()
+
+    def complete(self, messages, **kwargs):
+        with lock:
+            active["now"] += 1
+            active["peak"] = max(active["peak"], active["now"])
+        time.sleep(0.05)
+        with lock:
+            active["now"] -= 1
+        return json.dumps(breakdown())
+
+    monkeypatch.setattr(FakeClient, "complete", complete)
+    for index in range(6):
+        (tmp_path / f"s{index}.txt").write_text("CALLER: x", encoding="utf-8")
+
+    result = runner.invoke(
+        cli.app, ["--api-key", "k", "--concurrency", "4", "batch", str(tmp_path)]
+    )
+    assert result.exit_code == 0
+    assert active["peak"] > 1
+
+
+def test_max_cost_skips_remaining(home, tmp_path, fake, monkeypatch):
+    for index in range(4):
+        (tmp_path / f"s{index}.txt").write_text("CALLER: x", encoding="utf-8")
+
+    def complete(self, messages, **kwargs):
+        self.last_cost = 0.01
+        return json.dumps(breakdown())
+
+    monkeypatch.setattr(FakeClient, "complete", complete)
+    out = tmp_path / "r.md"
+    result = runner.invoke(
+        cli.app,
+        ["--api-key", "k", "--max-cost", "0.015", "batch", str(tmp_path), "--output", str(out)],
+    )
+    assert "skipped at the cost budget" in result.stdout
+    markdown = out.read_text()
+    assert "Skipped at budget" in markdown
+    assert "## Skipped" in markdown
+
+
+def test_max_cost_warns_when_provider_reports_nothing(home, tmp_path, fake):
+    (tmp_path / "a.txt").write_text("CALLER: x", encoding="utf-8")
+    result = runner.invoke(
+        cli.app, ["--api-key", "k", "--max-cost", "0.5", "analyze", "--file", str(tmp_path / "a.txt")]
+    )
+    assert result.exit_code == 0
+    assert "could not be enforced" in result.stdout

{scamscript-0.3.0 → scamscript-0.4.0}/tests/test_client.py

@@ -276,3 +276,36 @@ def test_length_with_only_reasoning_is_truncation():
         with pytest.raises(TruncatedError) as excinfo:
             client.complete(MESSAGES)
     assert excinfo.value.partial == "thinking..."
+
+
+def test_usage_is_thread_local():
+    import threading
+
+    def handler(request):
+        content = json.loads(request.read())["messages"][-1]["content"]
+        return httpx.Response(
+            200,
+            json={
+                "choices": [{"message": {"content": content}}],
+                "usage": {"prompt_tokens": 1, "completion_tokens": 1, "cost": float(len(content))},
+            },
+        )
+
+    client = ChatClient(
+        api_key="k",
+        base_url="https://example.test/v1",
+        transport=httpx.MockTransport(handler),
+    )
+    seen = {}
+
+    def run(role, text):
+        client.complete([{"role": role, "content": text}])
+        seen[role] = client.last_cost
+
+    threads = [threading.Thread(target=run, args=("a", "xx")), threading.Thread(target=run, args=("b", "xxxx"))]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join()
+    client.close()
+    assert seen == {"a": 2.0, "b": 4.0}

{scamscript-0.3.0 → scamscript-0.4.0}/tests/test_render.py

@@ -76,9 +76,14 @@ def test_prompt_panel():
 
 
 def test_summary_table_row_states():
-    text = capture(render_summary_table([("ok.txt", breakdown(), None), ("bad.txt", None, "boom")]))
+    text = capture(
+        render_summary_table(
+            [("ok.txt", breakdown(), None, False), ("bad.txt", None, "boom", False), ("skip.txt", None, "skipped", True)]
+        )
+    )
     assert "ok.txt" in text
     assert "boom" in text
+    assert "skipped" in text
 
 
 def test_panel_shows_quote_check():