capt-hook 3.7.0__tar.gz → 3.9.0__tar.gz

{capt_hook-3.7.0 → capt_hook-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capt-hook
-Version: 3.7.0
+Version: 3.9.0
 Summary: Declarative hook framework for Claude Code
 Keywords: claude,claude-code,hooks,llm,agents,guardrails,cli
 Author: Yasyf Mohamedali
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
 Classifier: Typing :: Typed
-Requires-Dist: cc-transcript>=3.2,<4
+Requires-Dist: cc-transcript>=4,<5
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-settings>=2.0
 Requires-Dist: tree-sitter>=0.24
@@ -30,7 +30,7 @@ Requires-Dist: wn>=1.1.0
 Requires-Dist: lazy-object-proxy>=1.12.0
 Requires-Dist: filelock>=3
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: spawnllm>=0.1.3
+Requires-Dist: spawnllm>=0.2.0
 Requires-Dist: pytest>=8.0 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.24 ; extra == 'dev'
 Requires-Dist: pyright>=1.1 ; extra == 'dev'

{capt_hook-3.7.0 → capt_hook-3.9.0}/captain_hook/packs/general/docs.py

@@ -12,7 +12,9 @@ from captain_hook import Allow, FilePath, Input, Tool, UsedSkill, Warn, nudge
 nudge(
     "You're editing documentation. Consult the writing-docs skill first for the "
     "Diataxis modes, voice rules, and code-sample rules, then run "
-    "`slop-cop check <file> --lang=markdown` to catch prose tells before you finish.",
+    "`slop-cop check <file> --lang=markdown` to catch prose tells before you finish. "
+    "slop-cop is a Go binary — if it's not on PATH, run the `/slop-cop-check` skill "
+    "(it installs it), never `uvx slop-cop`.",
     only_if=[Tool("Write|Edit"), FilePath("**/*.md", "**/*.qmd", "docs/**", "README.md")],
     skip_if=[UsedSkill("writing-docs|writing-docs:writing-docs")],
     max_fires=1,

capt_hook-3.9.0/captain_hook/packs/go/capt-hook.toml

@@ -0,0 +1,4 @@
+name = "go"
+version = "0.1.0"
+description = "Go-specific guards: a go-test-before-commit gate, gofumpt/golangci-lint toolchain guards, and a go.mod nudge on module-resolution errors."
+hooks = "."

capt_hook-3.9.0/captain_hook/packs/go/testing.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from captain_hook import (
+    Allow,
+    BaseHookEvent,
+    Block,
+    CustomCondition,
+    Event,
+    FilePath,
+    Input,
+    RanCommand,
+    Tool,
+    Warn,
+    gate,
+    nudge,
+)
+from captain_hook.types import Command as CommandCondition
+
+nudge(
+    """
+    When a test fails, isolate the minimal failing case before retrying. Use a
+    `-run TestName/case` regex or a single package path. Broad `go test ./...`
+    re-runs after a failure waste cycles and hide the real breakage.
+    """,
+    only_if=[Tool("Edit|Write"), FilePath("*_test.go")],
+)
+
+
+class UserSaid(CustomCondition):
+    """Matches when the user's messages contain any of the given keywords."""
+
+    def __init__(self, *keywords: str) -> None:
+        self.keywords = keywords
+
+    def check(self, evt: BaseHookEvent) -> bool:
+        return evt.ctx.t.user_said(*self.keywords)
+
+
+class AllEditsUnder(CustomCondition):
+    """Matches when every edit this session is under one of the given path prefixes."""
+
+    def __init__(self, *prefixes: str) -> None:
+        self.prefixes = prefixes
+
+    def check(self, evt: BaseHookEvent) -> bool:
+        return bool(files := evt.ctx.t.edited_files) and all(f.under(*self.prefixes) for f in files)
+
+
+class CommitsGo(CustomCondition):
+    """Matches when the git command explicitly names a Go path."""
+
+    def check(self, evt: BaseHookEvent) -> bool:
+        return bool(cl := evt.command_line) and ".go" in str(cl.primary)
+
+
+gate(
+    "No `go test` execution found. Run tests before committing Go changes.",
+    only_if=[Tool("Bash"), CommandCondition(r"git\s+commit"), CommitsGo()],
+    skip_if=[
+        RanCommand(r"go test"),
+        UserSaid("commit", "just commit"),
+        AllEditsUnder("docs/", ".claude/", ".github/"),
+    ],
+    events=Event.PreToolUse,
+    tests={
+        Input(command="git status"): Allow(),
+        Input(command="git commit internal/cli/root.go"): Block(),
+    },
+)
+
+
+nudge(
+    "No `go test` execution detected in this session. If you changed Go files, run tests "
+    "before committing. If this is a docs/config-only change, proceed.",
+    only_if=[Tool("Bash"), CommandCondition(r"git\s+commit")],
+    skip_if=[
+        RanCommand(r"go test"),
+        UserSaid("commit", "just commit"),
+        AllEditsUnder("docs/", ".claude/", ".github/"),
+        CommitsGo(),
+    ],
+    events=Event.PreToolUse,
+    tests={
+        Input(command="git status"): Allow(),
+        Input(command="git commit -m wip"): Warn(),
+    },
+)

capt_hook-3.9.0/captain_hook/packs/go/toolchain.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import re
+
+from captain_hook import Allow, Block, Event, Input, Tool, block_command, nudge
+from captain_hook.events import PostToolUseFailureEvent
+
+block_command(
+    r"^gofumpt\b",
+    reason="Do not run gofumpt manually — formatting is applied by the commit hook (golangci-lint fmt)",
+    hint="See AGENTS.md § Mechanical Linting. The prek hook formats on commit; `task fmt` runs it deliberately.",
+    tests={
+        Input(command="gofumpt -w ."): Block(),
+        Input(command="go build ./..."): Allow(),
+    },
+)
+
+block_command(
+    r"^golangci-lint\b",
+    reason="Do not run golangci-lint manually — CI and the commit hook own linting",
+    hint="See AGENTS.md § Mechanical Linting. Only fix issues requiring human judgment.",
+    tests={
+        Input(command="golangci-lint run"): Block(),
+        Input(command="golangci-lint fmt"): Block(),
+        Input(command="go vet ./..."): Allow(),
+        Input(command="uvx prek run --all-files"): Allow(),
+    },
+)
+
+nudge(
+    "MISSING DEPENDENCY: run `go mod tidy` (or `go get <module>`) to resolve it. "
+    "Do NOT make the import lazy, delete the importing code, or vendor by hand.",
+    events=Event.PostToolUseFailure,
+    only_if=[Tool("Bash")],
+    when=lambda evt: (
+        isinstance(evt, PostToolUseFailureEvent)
+        and bool(
+            re.search(
+                r"no required module provides package|missing go\.sum entry|"
+                r"cannot find module|updates to go\.mod needed",
+                evt.error,
+            )
+        )
+    ),
+    max_fires=2,
+)

{capt_hook-3.7.0 → capt_hook-3.9.0}/captain_hook/review/cli.py

@@ -21,6 +21,8 @@ import click
 if TYPE_CHECKING:
     from typing import Any
 
+    from cc_transcript.corrections import Correction
+
     from captain_hook.cli import CliState
     from captain_hook.review.judge import JudgeReport
     from captain_hook.review.repo import RepoKey
@@ -229,26 +231,52 @@ def list_candidates(state: CliState, repo_: str | None) -> None:
         click.echo(candidate_line(row))
 
 
+def correction_lines(correction: Correction) -> tuple[str, ...]:
+    match correction.correction_origin:
+        case "session" | "git":
+            return (
+                f"  correction ({correction.correction_origin}):",
+                f"    - {correction.correction_old}",
+                f"    + {correction.correction_new}",
+            )
+        case _ if correction.correction_text:
+            return (f"  correction note: {correction.correction_text}",)
+        case _:
+            return ()
+
+
+def correction_block(correction: Correction) -> str:
+    return "\n".join(
+        (
+            f"- {correction.incorrect_file} (session {correction.session_id}):",
+            f"    - {correction.incorrect_old}",
+            f"    + {correction.incorrect_new}",
+            *correction_lines(correction),
+        )
+    )
+
+
 @review.command()
 @click.argument("candidate_id", type=int)
 def show(candidate_id: int) -> None:
-    """Show one candidate's row and its threshold status."""
+    """Show one candidate's row, its threshold status, and the shared ledger's faulted edits."""
     from captain_hook.review.judge import REVIEW_PROMPT_VERSION
     from captain_hook.review.settings import ReviewSettings
     from captain_hook.review.store import ReviewStore
 
     settings = ReviewSettings()
 
-    async def go() -> tuple[dict[str, object], ThresholdStatus, bool]:
+    async def go() -> tuple[dict[str, object], ThresholdStatus, bool, tuple[Correction, ...]]:
         async with await ReviewStore.open(settings.db_path) as store:
             return (
                 await store.candidate(candidate_id),
                 await store.threshold_status(candidate_id, settings=settings, prompt_version=REVIEW_PROMPT_VERSION),
                 await store.eligible(candidate_id, settings=settings, prompt_version=REVIEW_PROMPT_VERSION),
+                await store.correction_evidence(candidate_id),
             )
 
     try:
-        row, status, ok = asyncio.run(go())
+        row, status, ok, evidence = asyncio.run(go())
     except LookupError as exc:
         raise click.ClickException(str(exc)) from exc
     for key, value in row.items():
@@ -257,6 +285,10 @@ def show(candidate_id: int) -> None:
         f"thresholds: sessions={status.sessions} days={status.days} open_prs={status.open_prs} "
         f"single_observation={status.single_observation} eligible={ok}"
     )
+    if evidence:
+        click.echo("correction_evidence:")
+        for correction in evidence:
+            click.echo(correction_block(correction))
 
 
 @review.command(name="threshold-check")

{capt_hook-3.7.0 → capt_hook-3.9.0}/captain_hook/review/scan.py

@@ -30,6 +30,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from itertools import chain
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from cc_transcript.activity import SessionActivity
@@ -76,7 +77,6 @@ from captain_hook.review.store import CandidateKind
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Mapping, Sequence
-    from pathlib import Path
     from typing import Any
 
     from cc_transcript.backend import ParsedTranscript
@@ -243,6 +243,39 @@ def transcript_repo(events: Sequence[TranscriptEvent]) -> RepoKey | None:
     )
 
 
+def transcript_cwd(events: Sequence[TranscriptEvent]) -> Path | None:
+    return next(
+        (Path(meta.cwd) for event in events if (meta := event_meta(event)) is not None if meta.cwd is not None),
+        None,
+    )
+
+
+async def record_corrections(
+    events: Sequence[TranscriptEvent], kept: Sequence[tuple[MiningSignal, FeedbackCandidate]], *, repo: Path | None
+) -> None:
+    """Grounds each user-correction candidate in the shared code-correction ledger.
+
+    For every kept user-correction signal (the FIX-mode ``hook_complaint`` is a
+    local hook misfire, not a code correction, so it is skipped), harvests the
+    edit the feedback faults around its anchor and appends one row to the family
+    ledger. Idempotent per anchor: a no-op when cc-pushback already wrote it, so
+    captain-hook only fills the ledger for sessions nobody else processed.
+    """
+    from cc_transcript.corrections import CorrectionLog
+    from cc_transcript.extract import extract_correction, usable_backend
+
+    corrections = [(sig, candidate) for sig, candidate in kept if sig.kind != HOOK_COMPLAINT]
+    if not corrections:
+        return
+    activity = SessionActivity.from_events(corrections[0][0].session_id, events)
+    backend = usable_backend()
+    log = CorrectionLog.open()
+    for sig, candidate in corrections:
+        await extract_correction(
+            log, activity, candidate.ref, source="captain-hook", feedback=sig.text, repo=repo, backend=backend
+        )
+
+
 async def ingest(
     store: ReviewStore, parsed: ParsedTranscript, *, settings: ReviewSettings, repo_key: RepoKey | None
 ) -> ScanReport:
@@ -275,6 +308,7 @@ async def ingest(
         await store.record_observation(
             candidate_id, dedup_key=candidate.dedup_key, session_id=sig.session_id, occurred_at=sig.occurred_at
         )
+    await record_corrections(parsed.events, kept, repo=transcript_cwd(parsed.events))
     return ScanReport(scanned=1, inserted=inserted)
 
 

{capt_hook-3.7.0 → capt_hook-3.9.0}/captain_hook/review/store.py

@@ -28,6 +28,7 @@ if TYPE_CHECKING:
     from pathlib import Path
     from typing import Any
 
+    from cc_transcript.corrections import Correction
     from cc_transcript.ids import SessionId
     from cc_transcript.mining.candidates import DedupKey
     from cc_transcript.mining.confidence import Confidence
@@ -105,6 +106,14 @@ WHERE o.candidate_id = ? AND l.accepted = 1 AND l.confidence >= ?
 
 OPEN_PRS_QUERY = "SELECT COUNT(*) AS n FROM candidates WHERE repo_key = ? AND status = ? AND pr_opened_at > ?"
 
+OBSERVATION_ANCHORS_QUERY = """
+SELECT DISTINCT e.session_id, e.event_uuid
+FROM candidate_observations o
+JOIN feedback_events e ON e.dedup_key = o.dedup_key
+WHERE o.candidate_id = ? AND e.session_id IS NOT NULL AND e.event_uuid IS NOT NULL
+ORDER BY o.id
+"""
+
 CANDIDATES_QUERY = """
 SELECT c.*,
   (SELECT e.text FROM candidate_observations o JOIN feedback_events e ON e.dedup_key = o.dedup_key
@@ -502,6 +511,26 @@ class ReviewStore(VerdictStoreMixin, FeedbackStore):
         )
         return str(rows[0]["summary"]) if (rows := [dict(row) async for row in cur]) else None
 
+    async def correction_evidence(self, candidate_id: int) -> tuple[Correction, ...]:
+        """Returns the shared-ledger code corrections grounding a candidate's observations.
+
+        Joins each observation back to its feedback anchor ``(session_id,
+        event_uuid)`` and pulls the corrections the family ledger holds for that
+        anchor — the offending before/after edit the PR-drafting brain needs. The
+        reviewer's own per-session pass writes these rows, so a candidate that
+        crossed its thresholds carries its faulted edits.
+        """
+        from cc_transcript.corrections import CorrectionLog
+        from cc_transcript.ids import EventUuid, SessionId
+
+        cur = await self.store.conn.execute(OBSERVATION_ANCHORS_QUERY, (candidate_id,))
+        log = CorrectionLog.open()
+        return tuple(
+            correction
+            for row in [dict(row) async for row in cur]
+            for correction in log.for_anchor(SessionId(str(row["session_id"])), EventUuid(str(row["event_uuid"])))
+        )
+
     async def candidate_view(
         self, row: dict[str, object], *, settings: ReviewSettings, prompt_version: int
     ) -> CandidateView:

{capt_hook-3.7.0 → capt_hook-3.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "capt-hook"
-version = "3.7.0"
+version = "3.9.0"
 description = "Declarative hook framework for Claude Code"
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"
@@ -20,7 +20,7 @@ classifiers = [
 ]
 requires-python = ">=3.13"
 dependencies = [
-    "cc-transcript>=3.2,<4",
+    "cc-transcript>=4,<5",
     "pydantic>=2.0",
     "pydantic-settings>=2.0",
     "tree-sitter>=0.24",
@@ -34,7 +34,7 @@ dependencies = [
     "lazy-object-proxy>=1.12.0",
     "filelock>=3",
     "loguru>=0.7.3",
-    "spawnllm>=0.1.3",
+    "spawnllm>=0.2.0",
 ]
 
 [project.optional-dependencies]