Answer stability round 1: 1 🔴, 6 🟡 (0 misread); read every title through both templates, hold a title to its template only on an item's branch, and fail on a config fault
This commit is contained in:
+1
-1
@@ -2,7 +2,7 @@
|
||||
|
||||
## Unreleased
|
||||
|
||||
- A project's config may name the language its prose is written in (`language`) and templates for its commit titles, pull request titles and branch names (`commit-title`, `pull-request-title`, `branch`), filled from `{id}` and `{summary}`. The tools and the prose reviewer follow them, and rule-hook's new `commit-title` rule refuses a commit title that doesn't fit.
|
||||
- A project's config may name the language its prose is written in (`language`) and templates for its commit titles, pull request titles and branch names (`commit-title`, `pull-request-title`, `branch`), in which `{id}` stands for the plan item's ID and `{summary}` for the one-line summary. The tools and the prose reviewer follow them. On a branch that fits the `branch` template, rule-hook's new `commit-title` rule refuses a commit title that doesn't fit, and `chunk-pr` such a pull request title. While a project's config holds a fault, rule-hook refuses every commit there.
|
||||
- `chunk-pr merge` waits for a human's approval of the pull request where the project's config sets `wait-for-approval = true`: it merges once GitHub reports the pull request approved, and gives up after 90 minutes. It reads approvals on GitHub only. Set it for a client whose pull requests need another person's approval.
|
||||
- The technical principles ask for code in files and folders before `// --- name ---` banner comments. They also ask for an entry point a newcomer finds at once: the root holds it, the README and the files a tool reads only from there.
|
||||
- In a client project, the loop reads the team's own `CLAUDE.md` and `AGENTS.md` and proposes each change that aligns them with this setup in a pull request of its own. Where the team declines or doesn't answer, the loop follows the team's rule unless it breaks a project goal, and records the conflict as a decision in the `decisions` record.
|
||||
|
||||
@@ -34,7 +34,7 @@ Fewer items shipped per release is a price this goal accepts, not a counter-sign
|
||||
|
||||
## Prose
|
||||
|
||||
Everything written — chat, commit messages, comments, docs, code — is in **English**. Where a project's config names another `language`, which `~/.claude/bin/project-config language` prints, the prose that project's readers see is in that language instead: its docs, comments, commit messages, pull requests and tracker text. Chat, names in code, and the fixed words a tool reads in a title, such as `Answer <pass> round <n>:`, stay English. Prose meets four priorities, in this order. When two pull against each other, the higher one wins.
|
||||
Everything written — chat, commit messages, comments, docs, code — is in **English**. Where a project's config names another `language`, which `~/.claude/bin/project-config language` prints, the prose that project's readers see is in that language instead: its docs, comments, commit messages, pull requests and tracker text. These stay English: chat, names in code, a reviewer's report, and what a tool reads, which is the fixed words of a title, such as `Answer <pass> round <n>:`, `todo.md`'s table, and a record's headings, such as `## Unreleased`. Prose meets four priorities, in this order. When two pull against each other, the higher one wins.
|
||||
|
||||
1. **Easy to understand.** A reader with little time gets it on one read: one idea per sentence, and each term explained before it is used.
|
||||
2. **Most important first**, judged by what the reader wants to know first.
|
||||
@@ -91,7 +91,7 @@ The rules only reviewers apply, for quality, comments, READMEs and prose, live i
|
||||
## Git, commits, and PRs
|
||||
- Mark no commit, PR, issue comment or file as the work of Claude, Anthropic or an agent.
|
||||
- Commit message and PR title: **one line**, prefixed with the ticket ID when the work has one. Example: `ABC-123 - Regression tests for GET /v4/clients`. Never include the repo/project name (like "twu-4") — we're already in that context.
|
||||
- Where the project's config names a `commit-title`, `pull-request-title` or `branch` template, fill it instead of following the formats in this section: `{summary}` with that one line, `{id}` with the ID of the chunk's first item. `~/.claude/bin/project-config --help` describes the templates, and `chunk-preflight`'s facts quote them. A title a tool reads, such as `Answer <pass> round <n>: …`, `Drop item <ID>: …` or `Release review of <release>`, is the template's `{summary}`.
|
||||
- Where the project's config names a `commit-title`, `pull-request-title` or `branch` template, fill it instead of following the formats in this section. `{summary}` is the one line that says what the change does, without a ticket ID, and `{id}` is the ID of the chunk's first item. A chunk without a plan item, such as a release review, works on a branch that doesn't fit the `branch` template, and its titles are the summary alone. `~/.claude/bin/project-config --help` describes the templates, and `chunk-preflight`'s facts quote them. A title a tool reads, such as `Answer <pass> round <n>: …`, `Drop item <ID>: …` or `Release review of <release>`, is the template's `{summary}`.
|
||||
- When the work has a ticket, read it before starting: verify the change matches it and pull useful context from it.
|
||||
- PR summary: short and concise. No test plan (it lives in the ticket), no link to the ticket (it's in the title).
|
||||
- Branch for a ticket: exactly the ticket ID, nothing more. `ABC-123`, never `ABC-123-some-description`.
|
||||
|
||||
@@ -96,7 +96,7 @@ principles = "~/.claude/principles"
|
||||
|
||||
A project may also set `env-file`, the file of `KEY=value` credentials its tools read, such as `env-file = "~/.claude-projects/log.env"`. It is a path that starts with `/` or `~/`, outside the checkout and the config's folder, so that no git remote receives it. A tool that needs a key fails and names each one the file lacks. No failure message, prompt, log line or archived loop output holds a token from the file. rule-hook refuses a Read or a Grep of the file and a Bash command that names it or searches a folder holding it with `ag`, `grep -r` or `rg`, unless the tool skips the file as hidden or ignored, so a worker doesn't read it in passing; `rule-hook --help` says which calls it checks. A project without the setting has no credentials, and never reads another project's. `project-config env-file` prints the path.
|
||||
|
||||
A project whose owners write in another language than English, or title their commits, pull requests and branches otherwise than `CLAUDE.md` → "Git, commits, and PRs" does, sets `language`, `commit-title`, `pull-request-title` and `branch` in its config, as `project-config --help` describes. The worker writes the project's prose in that language and the prose reviewer judges it there. rule-hook refuses a commit, and `chunk-pr` a pull request, whose title doesn't fit its template, and `chunk-preflight` names the branch and the worktree by the `branch` template. Every tool that reads a commit title, such as a round's `Answer <pass> round <n>:`, reads it as the template's `{summary}`.
|
||||
A project's config may set four more things, each optional, as `project-config --help` describes. `language` names the language its owners write in, where that isn't English: the worker writes the project's prose in it, and the prose reviewer judges the prose in it. `commit-title`, `pull-request-title` and `branch` are templates for a project that titles and names these in another way than `CLAUDE.md` → "Git, commits, and PRs" says. `chunk-preflight` names the branch and the worktree by the `branch` template. On a branch that fits it, rule-hook refuses a commit, and `chunk-pr` a pull request, whose title doesn't fit its template; on any other branch, such as a release review's, a title is the summary alone. A tool that reads a commit title, such as a round's `Answer <pass> round <n>:`, reads the template's `{summary}`: it tries `commit-title`, then `pull-request-title`, since a squash merge titles the commit as the pull request, then takes the title whole. While a project's config holds a fault, rule-hook refuses every commit there, and the tools that read its titles fail naming the fault.
|
||||
|
||||
A project whose pull requests need a human's approval sets `wait-for-approval = true` in its config. `chunk-pr merge` then waits, once the checks have passed, until GitHub reports the pull request approved as its branch protection requires, and merges it. It refuses on Gitea, where a reviewer requested changes and where the protection requires no review. It gives up after 90 minutes without an approval; run it again once the pull request is approved. Left out, the setting is false.
|
||||
|
||||
|
||||
@@ -15,7 +15,7 @@ The bar, read each time, since it changes:
|
||||
|
||||
Verdict, severities and rounds: ~/.claude/skills/larv-review/review-findings.md.
|
||||
|
||||
Your prompt's `Prose language:` line names the language the project's config sets. Judge every check below in that language, by its own grammar and idiom: where the bar's examples are English, hold the prose to what they show, never to their English wording. Prose in another language is a finding, except chat, names in code and the fixed words a tool reads in a title. Write your report in English.
|
||||
Your prompt's `Prose language:` line names the language the project's config sets. Apply every check below to prose in that language, by that language's grammar and idiom. The bar's examples are English: find the same fault in the other language, never the same English words. Prose in another language is a finding, except what `standards/prose.md` says stays English. Write your report in English.
|
||||
|
||||
## Checks, in priority order
|
||||
|
||||
|
||||
@@ -59,9 +59,9 @@ class Branch:
|
||||
owner: dict[str, int]
|
||||
|
||||
|
||||
def cut_branch(log: str, template: str = templates.TITLE) -> Branch | Failure:
|
||||
def cut_branch(log: str, titles: templates.Titles) -> Branch | Failure:
|
||||
"""The branch LOG printed, cut into chunks as chunk_log cuts its first-parent line; a commit belongs to the oldest chunk whose commits reach it."""
|
||||
commits = parsed(log, template)
|
||||
commits = parsed(log, titles)
|
||||
if isinstance(commits, Failure):
|
||||
return commits
|
||||
if not commits:
|
||||
@@ -72,9 +72,9 @@ def cut_branch(log: str, template: str = templates.TITLE) -> Branch | Failure:
|
||||
line.append(commits[line[-1].parents[0]])
|
||||
runs = chunk_log(line)
|
||||
owner = owners(runs, commits)
|
||||
titles: list[list[str]] = [[] for _ in runs]
|
||||
held: list[list[str]] = [[] for _ in runs]
|
||||
for commit in commits.values():
|
||||
titles[owner[commit.hash]].append(commit.title)
|
||||
held[owner[commit.hash]].append(commit.title)
|
||||
spans = []
|
||||
for index, run in enumerate(runs):
|
||||
spans.append(Span(
|
||||
@@ -83,13 +83,13 @@ def cut_branch(log: str, template: str = templates.TITLE) -> Branch | Failure:
|
||||
label=label(run[-1].short, run[0].short),
|
||||
landing=landing(run),
|
||||
merged=utc(run[0].committed),
|
||||
titles=tuple(titles[index]),
|
||||
titles=tuple(held[index]),
|
||||
))
|
||||
return Branch(commits, spans, owner)
|
||||
|
||||
|
||||
def parsed(log: str, template: str) -> dict[str, Commit] | Failure:
|
||||
"""Each commit LOG printed, by hash, in the order it printed them, its title read as its summary in template, the project's `commit-title`. So a round title or a `Drop item` title reads the same in every project."""
|
||||
def parsed(log: str, titles: templates.Titles) -> dict[str, Commit] | Failure:
|
||||
"""Each commit LOG printed, by hash, in the order it printed them, its title read as its summary in titles, the project's title templates. So a round title or a `Drop item` title reads the same in every project."""
|
||||
commits = {}
|
||||
for record in log.split("\x00")[1:]:
|
||||
found = LOG_RECORD.fullmatch(record)
|
||||
@@ -97,7 +97,7 @@ def parsed(log: str, template: str) -> dict[str, Commit] | Failure:
|
||||
return Failure(f"git log printed a commit it could not read: {record[:200]!r}")
|
||||
full, committed, authored, parents, short, rest = found.groups()
|
||||
title, *files = rest.split("\n")
|
||||
commits[full] = Commit(full, short, int(committed), int(authored), tuple(parents.split()), templates.summary_of(template, title), tuple(name for name in files if name))
|
||||
commits[full] = Commit(full, short, int(committed), int(authored), tuple(parents.split()), titles.summary(title), tuple(name for name in files if name))
|
||||
return commits
|
||||
|
||||
|
||||
|
||||
@@ -33,15 +33,15 @@ def held(config: ProjectConfig, name: str) -> tuple[str, str | None]:
|
||||
return record.label, record.tracked
|
||||
|
||||
|
||||
def branch_chunks(default: str, run: Git, template: str = templates.TITLE) -> list[BranchChunk] | Failure:
|
||||
def branch_chunks(default: str, run: Git, titles: templates.Titles) -> list[BranchChunk] | Failure:
|
||||
"""Each chunk on the default branch's first-parent line, newest first, with the todo.md items it shipped and the later chunks that fixed code it shipped.
|
||||
|
||||
template is the project's `commit-title`, which each commit's title is read through. run must run git in the checkout's top: the diff names each path from the top, while blame and a pathspec read a path from the current directory."""
|
||||
titles holds the project's title templates, which each commit's title is read through. run must run git in the checkout's top: the diff names each path from the top, while blame and a pathspec read a path from the current directory."""
|
||||
# The -- keeps a file named like the branch from making it ambiguous.
|
||||
log = run(*LOG, default, "--")
|
||||
if isinstance(log, Failure):
|
||||
return log
|
||||
branch = cut_branch(log, template)
|
||||
branch = cut_branch(log, titles)
|
||||
if isinstance(branch, Failure):
|
||||
return branch
|
||||
plans = plans_at(plan_revisions(branch), run)
|
||||
|
||||
@@ -9,6 +9,7 @@ import unittest.mock
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from project_config.templates import BARE, Titles
|
||||
from branch_chunks.fixes import blamed, fixing_changes, removed, removed_work, Traced, with_fixes
|
||||
from branch_chunks.cut import Branch, chunk_log, Commit, cut_branch, landing, NOT_WORK, shipped, Span
|
||||
from branch_chunks.read import branch_chunks, traced_to, unsupported
|
||||
@@ -77,21 +78,21 @@ class Shipped(unittest.TestCase):
|
||||
|
||||
class CutBranch(unittest.TestCase):
|
||||
def test_reads_a_title_that_holds_a_control_character(self):
|
||||
found = cut_branch(f"\x00{'a' * 40} 100 100 \x1faaaaaaa\x1fTake \x1e and \x1f\n\nb.py\n")
|
||||
found = cut_branch(f"\x00{'a' * 40} 100 100 \x1faaaaaaa\x1fTake \x1e and \x1f\n\nb.py\n", BARE)
|
||||
self.assertNotIsInstance(found, Failure)
|
||||
self.assertEqual([found.titles for found in found.chunks], [("Take \x1e and \x1f",)])
|
||||
|
||||
def test_reads_each_title_as_its_summary_in_the_projects_commit_title_template(self):
|
||||
log = f"\x00{'a' * 40} 100 100 {'b' * 40}\x1faaaaaaa\x1fPAY-7 - Drop item 6: moot\n\nb.py\n\x00{'b' * 40} 90 90 \x1fbbbbbbb\x1fFrom before the template\n\nb.py\n"
|
||||
found = cut_branch(log, "PAY-{id} - {summary}")
|
||||
found = cut_branch(log, Titles("PAY-{id} - {summary}", "{summary}"))
|
||||
self.assertNotIsInstance(found, Failure)
|
||||
self.assertEqual(sorted(title for chunk in found.chunks for title in chunk.titles), ["Drop item 6: moot", "From before the template"])
|
||||
|
||||
def test_fails_on_a_commit_it_cannot_read(self):
|
||||
self.assertIsInstance(cut_branch(f"\x00{'a' * 40} 100\x1faaaaaaa\n"), Failure)
|
||||
self.assertIsInstance(cut_branch(f"\x00{'a' * 40} 100\x1faaaaaaa\n", BARE), Failure)
|
||||
|
||||
def test_fails_on_a_log_that_holds_no_commit(self):
|
||||
self.assertIsInstance(cut_branch(""), Failure)
|
||||
self.assertIsInstance(cut_branch("", BARE), Failure)
|
||||
|
||||
|
||||
class ChunkLog(unittest.TestCase):
|
||||
@@ -255,10 +256,10 @@ class BranchChunks(unittest.TestCase):
|
||||
self.env.pop(name)
|
||||
return self.git("rev-parse", "--short", "HEAD").strip()
|
||||
|
||||
def read(self, run=None, **template):
|
||||
def read(self, run=None, titles=BARE):
|
||||
"""branch_chunks over main, run by git_repo's git, or else by run."""
|
||||
with unittest.mock.patch.dict(os.environ, self.env, clear=True):
|
||||
return branch_chunks("main", functools.partial(run or git, cwd=str(self.checkout)), **template)
|
||||
return branch_chunks("main", functools.partial(run or git, cwd=str(self.checkout)), titles)
|
||||
|
||||
def fixing_history(self):
|
||||
"""Merges seven chunks onto main, then checks out a branch off it. Returns each of main's chunks by label, with the chunks that fixed it.
|
||||
@@ -319,12 +320,12 @@ class BranchChunks(unittest.TestCase):
|
||||
def test_reads_a_drop_title_through_the_projects_commit_title(self):
|
||||
self.merge("four", "Do four", {"b.py": "x\ny\n", "todo.md": todo(SECOND, FIX)}, "2026-10-13T10:00:00Z")
|
||||
self.merge("six", "PAY-6 Drop item 6: item 4 fixed it", {"b.py": "x\nY\n", "todo.md": todo(SECOND)}, "2026-10-14T10:00:00Z")
|
||||
found = self.read(template="PAY-{id} {summary}")
|
||||
found = self.read(titles=Titles("{summary}", "PAY-{id} {summary}"))
|
||||
self.assertNotIsInstance(found, Failure)
|
||||
self.assertEqual([[item.id for item in found.shipped] for found in found[:2]], [[], [4]])
|
||||
|
||||
def test_fails_where_git_cannot_read_the_branch(self):
|
||||
self.assertEqual(branch_chunks("main", lambda *args: Failure("no log")), Failure("no log"))
|
||||
self.assertEqual(branch_chunks("main", lambda *args: Failure("no log"), BARE), Failure("no log"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
+12
-10
@@ -11,9 +11,10 @@ pull request only while its head is the commit checked out, so push before you r
|
||||
|
||||
open pushes the branch, setting its upstream, and opens a draft pull request into origin's
|
||||
default branch. <title> is one line, as ~/.claude/CLAUDE.md → "Git, commits, and PRs"
|
||||
says, and <body> is the pull request's summary. It refuses a <title> that doesn't fit the
|
||||
`pull-request-title` template the project's config names (`project-config --help`), as
|
||||
ready does, and fails where no config names the checkout. Where the branch's pull request is open
|
||||
says, and <body> is the pull request's summary. On a branch that fits the config's `branch`
|
||||
template, it refuses a <title> that doesn't fit the `pull-request-title` template the
|
||||
project's config names (`project-config --help`); on any other branch, as for a
|
||||
chunk with no plan item, the title may be the bare summary. It fails where no config names the checkout. Where the branch's pull request is open
|
||||
already, it opens no second one. On origin's default branch it refuses without pushing anything.
|
||||
sync fetches origin and merges its default branch into the branch checked out, where the
|
||||
branch does not hold it already, and prints which it did. Then, where the project's config
|
||||
@@ -21,7 +22,8 @@ sync fetches origin and merges its default branch into the branch checked ou
|
||||
failing where the check fails or no config names the checkout. On a merge conflict it names the conflicted files and leaves the merge in
|
||||
progress, to resolve and commit. On origin's default branch it refuses and doesn't fetch anything.
|
||||
ready marks the pull request ready for review. On Gitea a draft is a pull request whose title
|
||||
starts with `WIP: `, so there it drops that prefix. Given <title>, one line, it sets that
|
||||
starts with `WIP: `, so there it drops that prefix. Given <title>, one line, which it holds
|
||||
to the template as open does, it sets that
|
||||
as the pull request's title first; where that fails, the pull request stays a draft.
|
||||
merge waits for the pull request's checks, and those origin's default branch requires, to pass
|
||||
on the head, then merges the pull request, and only while its head is still the commit
|
||||
@@ -105,12 +107,12 @@ def step(argv: list[str], run: Run) -> str | Failure:
|
||||
|
||||
|
||||
def misfit(title: str, run: Run) -> Failure | None:
|
||||
"""Why title doesn't fit the `pull-request-title` template the project's config names; None where it fits. A config that cannot be read fails, so that no pull request reaches the project's owners under a title they don't use."""
|
||||
template = run([str(BIN / "project-config"), "pull-request-title"])
|
||||
if isinstance(template, Failure):
|
||||
return template
|
||||
template = template.rstrip("\n")
|
||||
if templates.fits(template, title.strip()):
|
||||
"""Why title doesn't fit the `pull-request-title` template the project's config names; None where it fits. A branch that doesn't fit the config's `branch` template is no plan item's, so it has no ID for {id}, and any title fits there. A config that cannot be read fails, so that no pull request reaches the project's owners under a title they don't use."""
|
||||
read = [run([str(BIN / "project-config"), "pull-request-title"]), run([str(BIN / "project-config"), "branch"]), run(["git", "symbolic-ref", "--short", "HEAD"])]
|
||||
if failed := next((answer for answer in read if isinstance(answer, Failure)), None):
|
||||
return failed
|
||||
template, branch_template, branch = (answer.strip("\n") for answer in read if isinstance(answer, str))
|
||||
if not templates.branch_fits(branch_template, branch) or templates.fits(template, title.strip()):
|
||||
return None
|
||||
return Failure(f"title the pull request as the project's config asks, `{template}`, where {{id}} is the ID of the chunk's first item; {title.strip()!r} doesn't fit")
|
||||
|
||||
|
||||
@@ -26,6 +26,7 @@ TEA_BRANCH = ["tea", "api", "repos/{owner}/{repo}/branches/main"]
|
||||
TEA_STATUS = ["tea", "api", f"repos/{{owner}}/{{repo}}/commits/{HEAD}/status"]
|
||||
OWED = [str(pathlib.Path(__file__).resolve().parents[1] / "larv-review"), "scoring-run-owed"]
|
||||
TITLE = [str(pathlib.Path(__file__).resolve().parents[1] / "project-config"), "pull-request-title"]
|
||||
BRANCH = [str(pathlib.Path(__file__).resolve().parents[1] / "project-config"), "branch"]
|
||||
WAITS = [str(pathlib.Path(__file__).resolve().parents[1] / "project-config"), "wait-for-approval"]
|
||||
GH_DECISION = ["gh", "pr", "view", "12", "--json", "reviewDecision"]
|
||||
|
||||
@@ -52,6 +53,7 @@ class Checkout:
|
||||
("git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD"): "origin/main\n",
|
||||
tuple(WAITS): "false\n",
|
||||
tuple(TITLE): "{summary}\n",
|
||||
tuple(BRANCH): "item-{id}\n",
|
||||
}
|
||||
|
||||
def __call__(self, command: list[str]) -> str | Failure:
|
||||
@@ -85,6 +87,18 @@ class Checkout:
|
||||
|
||||
|
||||
class Open(unittest.TestCase):
|
||||
def test_a_title_must_fit_the_template_only_on_a_branch_that_fits_the_configs_branch_template(self):
|
||||
for argv in (["open", "Release review of 0.3.0"], ["ready", "Release review of 0.3.0"]):
|
||||
with self.subTest(argv=argv):
|
||||
checkout = Checkout(GITHUB, open=argv[0] == "ready")
|
||||
checkout.answers[tuple(TITLE)] = "PAY-{id} - {summary}\n"
|
||||
checkout.answers[tuple(BRANCH)] = "feature/PAY-{id}\n"
|
||||
self.assertNotIsInstance(step(argv, checkout), Failure)
|
||||
checkout.answers[("git", "symbolic-ref", "--short", "HEAD")] = "feature/PAY-7\n"
|
||||
refused = step(argv, checkout)
|
||||
assert isinstance(refused, Failure), refused
|
||||
self.assertIn("'Release review of 0.3.0' doesn't fit", refused.reason)
|
||||
|
||||
def test_github_pushes_and_opens_a_draft_into_the_default_branch(self):
|
||||
checkout = Checkout(GITHUB, open=False)
|
||||
opened = step(["open", "ABC-1 - Do it", "The body."], checkout)
|
||||
@@ -119,6 +133,9 @@ class Open(unittest.TestCase):
|
||||
self.assertNotIsInstance(step([argv[0], "PAY-7 - Do it"], checkout), Failure)
|
||||
checkout.answers[tuple(TITLE)] = Failure("no config names the checkout")
|
||||
self.assertEqual(step(argv, checkout), Failure("no config names the checkout"))
|
||||
checkout.answers[tuple(TITLE)] = "PAY-{id} - {summary}\n"
|
||||
checkout.answers[tuple(BRANCH)] = Failure("`branch` is 'x', which holds no {id}")
|
||||
self.assertEqual(step(argv, checkout), Failure("`branch` is 'x', which holds no {id}"))
|
||||
untitled = Checkout(GITHUB, open=True)
|
||||
untitled.answers[tuple(TITLE)] = Failure("no config names the checkout")
|
||||
self.assertNotIsInstance(step(["ready"], untitled), Failure)
|
||||
|
||||
@@ -5,7 +5,6 @@ from release_plan.release_standing import chunk_item, Cut, dated_cut, LastCut, R
|
||||
from failure import Failure
|
||||
from chunk_preflight.gathered import Forge, NoItem, Plan
|
||||
from release_plan.todo_table import item_details, items, NoItemsTable
|
||||
from project_config import templates
|
||||
from release_plan.release import version
|
||||
|
||||
# The command each forge's CLI lists pull requests with; pulls_command adds the flags that pick their rows and fields.
|
||||
@@ -25,8 +24,8 @@ def plan_name(default: str, outside: pathlib.Path | None) -> str:
|
||||
return str(outside) if outside else f"{default}'s todo.md"
|
||||
|
||||
|
||||
def planned(todo: str | Failure, cut: LastCut, default: str, outside: pathlib.Path | None = None, branch: str = templates.BRANCH) -> Plan | NoItem:
|
||||
"""The plan in todo, the text of the todo.md plan_name names, with the item the next chunk takes first, release_standing.chunk_item's pick; else why there is none."""
|
||||
def planned(todo: str | Failure, cut: LastCut, default: str, branch: str, outside: pathlib.Path | None = None) -> Plan | NoItem:
|
||||
"""The plan in todo, the text of the todo.md plan_name names, with the item the next chunk takes first, release_standing.chunk_item's pick; else why there is none. branch is the project's `branch` template."""
|
||||
where = plan_name(default, outside)
|
||||
if isinstance(todo, Failure):
|
||||
return NoItem(f"{where} cannot be read: {todo.reason}.")
|
||||
|
||||
@@ -18,7 +18,7 @@ def render(found: Gathered) -> list[str]:
|
||||
unseen = [f"- {UNSEEN_RELEASES}"] if found.plan_outside else []
|
||||
head = [*note, f"- {last_release(found.default, found.cut)}", *unseen]
|
||||
paths = f"- The project's config puts its files at: {'; '.join(f'{setting} {path}' for setting, path in found.paths.items())}."
|
||||
texts = f"- The project's config names: {'; '.join(f'{setting} {text}' for setting, text in found.texts.items())}."
|
||||
texts = f"- The project's config sets: {'; '.join(f'{setting} {text}' for setting, text in found.texts.items())}."
|
||||
if isinstance(found.item, NoItem):
|
||||
return [*head, f"- No plan item: {found.item.why} No worktree was made.", paths, texts]
|
||||
lines = item_lines(found.plan, found.item)
|
||||
|
||||
@@ -29,8 +29,7 @@ class Plan:
|
||||
text: str
|
||||
# Every item's detail by its ID, or why todo.md's details cannot be read.
|
||||
details: dict[int, str] | Failure
|
||||
# The project's `branch` template.
|
||||
branch_template: str = templates.BRANCH
|
||||
branch_template: str
|
||||
|
||||
@property
|
||||
def branch(self) -> str:
|
||||
@@ -89,4 +88,4 @@ class Gathered:
|
||||
# Whether the project's config puts the plan outside the checkout, where a release whose items are all done is not seen.
|
||||
plan_outside: bool
|
||||
# The language and the templates the project's config names, by their settings.
|
||||
texts: dict[str, str] = dataclasses.field(default_factory=dict)
|
||||
texts: dict[str, str]
|
||||
|
||||
@@ -29,9 +29,9 @@ and prints that the release reviews and the cuts are the human's to call. It pri
|
||||
such a commit counts only where its <release> is after the version under the dated heading.
|
||||
Where todo.md's earliest release is x.y.z or earlier, it says todo.md files items under a release
|
||||
already cut;
|
||||
- with --worktree, the item's worktree: a sibling of the checkout named <checkout>-item-<ID>, on
|
||||
the branch item-<ID>, or on the branch the config's `branch` template names, with the worktree
|
||||
named <checkout>-<branch>, each / of the branch a dash. It continues a worktree already on that branch; else it adds one on the
|
||||
- with --worktree, the item's worktree: a sibling of the checkout named <checkout>-<branch>,
|
||||
each / of the branch a dash, on the branch the config's `branch` template names, which is
|
||||
item-<ID> where the config names none. It continues a worktree already on that branch; else it adds one on the
|
||||
local branch, else on a new branch tracking origin's, else on a new branch off the default
|
||||
branch. Without --worktree, it prints that none was made;
|
||||
- each path the project's config sets, as `project-config` prints them in that worktree, or else
|
||||
@@ -67,14 +67,13 @@ import sys
|
||||
import typing
|
||||
|
||||
from git_cli.git_repo import commit_exists, default_branch, file_at, git, top
|
||||
from release_plan.release_standing import default_plan
|
||||
from failure import Failure
|
||||
from chunk_preflight.gathered import Forge, Gathered, ItemFacts, NamedPath, NoItem, Plan, Ran, Worktree
|
||||
from chunk_preflight.choices import forge_of, plan_name, planned, pulls_command, worktree_add, worktree_on
|
||||
from chunk_preflight.facts import JOINING_DETAILS, render
|
||||
from project_config.main import located
|
||||
from release_plan.named_code import named_paths
|
||||
from record_store.stores import store
|
||||
from release_plan.release_standing import project_plan
|
||||
|
||||
BIN = pathlib.Path(__file__).resolve().parents[1]
|
||||
# Each tool run in the item's worktree, {item} standing for the item's ID.
|
||||
@@ -129,8 +128,8 @@ def preflight(root: pathlib.Path, timeout: float, make: bool) -> list[str] | Fai
|
||||
if isinstance(config, Failure):
|
||||
return config
|
||||
outside = None if config.tracked("plan") else config.paths["plan"]
|
||||
held = default_plan(str(root), ref, config.place("plan"), store(config, "changelog"), title=config.commit_title)
|
||||
plan = planned(held.todo, held.cut, ref, outside, config.branch)
|
||||
held = project_plan(config, ref, str(root))
|
||||
plan = planned(held.todo, held.cut, ref, config.branch, outside)
|
||||
item = plan if isinstance(plan, NoItem) else item_facts(root, ref, plan, timeout, make)
|
||||
# A `checkout:` path lands in the worktree the chunk works in.
|
||||
made = located(str(item.worktree.path), pathlib.Path.home()) if isinstance(item, ItemFacts) and isinstance(item.worktree, Worktree) else config
|
||||
@@ -150,7 +149,7 @@ def item_worktree(root: pathlib.Path, branch: str, default: str) -> Worktree | F
|
||||
return listing
|
||||
if (path := worktree_on(listing, branch)) is not None:
|
||||
return Worktree(path, f"continued, on the branch {branch}.")
|
||||
# A branch such as feature/PAY-7 would nest the worktree in a folder, so its slashes become dashes.
|
||||
# A branch such as feature/7 would nest the worktree in a folder, so its slashes become dashes.
|
||||
path = root.parent / f"{root.name}-{branch.replace('/', '-')}"
|
||||
if path.exists():
|
||||
return Failure(f"none made, since {path} exists and holds no worktree on the branch {branch}")
|
||||
|
||||
@@ -8,6 +8,7 @@ import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from project_config.templates import BRANCH
|
||||
from failure import Failure
|
||||
from chunk_preflight.choices import forge_of, planned, worktree_add
|
||||
from chunk_preflight.gathered import Gathered, ItemFacts, NamedPath, NoItem, Ran, Worktree
|
||||
@@ -148,7 +149,7 @@ class ChunkPreflightTool(unittest.TestCase):
|
||||
repo = Repo(self)
|
||||
repo.push_from_elsewhere("todo.md", SHIPPED)
|
||||
plain = repo.preflight()
|
||||
self.assertIn("- The project's config names: language English; commit-title {summary}; pull-request-title {summary}; branch item-{id}.\n", plain.stdout)
|
||||
self.assertIn("- The project's config sets: language English; commit-title {summary}; pull-request-title {summary}; branch item-{id}.\n", plain.stdout)
|
||||
config = repo.temp / "home" / ".claude-projects" / "proj" / "config.toml"
|
||||
config.write_text(config.read_text() + 'language = "Swedish"\ncommit-title = "PAY-{id} - {summary}"\nbranch = "feature/PAY-{id}"\n')
|
||||
done = repo.preflight("--worktree")
|
||||
@@ -156,7 +157,7 @@ class ChunkPreflightTool(unittest.TestCase):
|
||||
worktree = repo.temp / "proj-feature-PAY-7"
|
||||
self.assertEqual(repo.git(worktree, "rev-parse", "--abbrev-ref", "HEAD").strip(), "feature/PAY-7")
|
||||
self.assertIn("- Open pull requests from feature/PAY-7: ", done.stdout)
|
||||
self.assertIn("- The project's config names: language Swedish; commit-title PAY-{id} - {summary}; pull-request-title {summary}; branch feature/PAY-{id}.\n", done.stdout)
|
||||
self.assertIn("- The project's config sets: language Swedish; commit-title PAY-{id} - {summary}; pull-request-title {summary}; branch feature/PAY-{id}.\n", done.stdout)
|
||||
|
||||
def test_reads_the_fetched_default_branchs_plan_and_makes_the_items_worktree_off_it_leaving_the_checkout_as_it_was(self):
|
||||
repo = Repo(self)
|
||||
@@ -358,7 +359,7 @@ class ChunkPreflightTool(unittest.TestCase):
|
||||
|
||||
def item_facts(todo=TODO, **fields):
|
||||
"""The facts of todo's next item, its worktree made, with fields given replacing the rest."""
|
||||
return ItemFacts(**{"plan": planned(todo, CUT, "origin/main"), "worktree": Worktree(pathlib.Path("/c/proj-item-3"), "added on the new branch item-3, made off origin/main."), "pulls": None, "named": [], "tools": [], **fields})
|
||||
return ItemFacts(**{"plan": planned(todo, CUT, "origin/main", BRANCH), "worktree": Worktree(pathlib.Path("/c/proj-item-3"), "added on the new branch item-3, made off origin/main."), "pulls": None, "named": [], "tools": [], **fields})
|
||||
|
||||
|
||||
def gathered(item, release=CUT, note=None, plan_outside=False):
|
||||
@@ -380,7 +381,7 @@ class Render(unittest.TestCase):
|
||||
|
||||
def test_states_each_fact_once_with_the_paths_between_the_worktree_and_the_open_pull_requests(self):
|
||||
lines = render(gathered(item_facts()))
|
||||
self.assertEqual([line.partition(":")[0] for line in lines[:6]], ["- Last version cut", "- The earliest release in origin/main's todo.md", "- Worktree", "- The project's config puts its files at", "- The project's config names", "- Open pull requests from item-3"])
|
||||
self.assertEqual([line.partition(":")[0] for line in lines[:6]], ["- Last version cut", "- The earliest release in origin/main's todo.md", "- Worktree", "- The project's config puts its files at", "- The project's config sets", "- Open pull requests from item-3"])
|
||||
self.assertEqual([line for line in lines[6:] if line.startswith("- Open pull requests")], [])
|
||||
|
||||
def test_says_that_a_plan_outside_the_checkout_hides_a_release_whose_items_are_all_done(self):
|
||||
@@ -507,40 +508,40 @@ class OpenPulls(unittest.TestCase):
|
||||
|
||||
class Plans(unittest.TestCase):
|
||||
def test_picks_the_earliest_releases_first_item_that_does_not_wait_or_says_why_there_is_none(self):
|
||||
self.assertEqual(planned(TODO, CUT, "origin/main").first.id, 3)
|
||||
waits = planned(TODO.replace("| 3 | 0.2.0 | | |", "| 3 | 0.2.0 | | question |"), CUT, "origin/main")
|
||||
self.assertEqual(planned(TODO, CUT, "origin/main", BRANCH).first.id, 3)
|
||||
waits = planned(TODO.replace("| 3 | 0.2.0 | | |", "| 3 | 0.2.0 | | question |"), CUT, "origin/main", BRANCH)
|
||||
self.assertIn("waits", waits.why)
|
||||
self.assertIn("0.2.0", waits.why)
|
||||
self.assertIn("Permission denied", planned(Failure("Permission denied"), CUT, "origin/main").why)
|
||||
self.assertEqual(planned(Failure("Permission denied"), CUT, "origin/main").why, "origin/main's todo.md cannot be read: Permission denied.")
|
||||
self.assertEqual(planned(Failure("Permission denied"), CUT, "origin/main", pathlib.Path("/projects/acme/todo.md")).why, "/projects/acme/todo.md cannot be read: Permission denied.")
|
||||
self.assertIn("L 'x'", planned(TODO.replace("| 2 | 2 | 3 | 5 |", "| x | 2 | 3 | 5 |"), CUT, "origin/main").why)
|
||||
self.assertIn("details cannot be read", planned(TODO + "```\n", CUT, "origin/main").text)
|
||||
self.assertIn("Permission denied", planned(Failure("Permission denied"), CUT, "origin/main", BRANCH).why)
|
||||
self.assertEqual(planned(Failure("Permission denied"), CUT, "origin/main", BRANCH).why, "origin/main's todo.md cannot be read: Permission denied.")
|
||||
self.assertEqual(planned(Failure("Permission denied"), CUT, "origin/main", BRANCH, pathlib.Path("/projects/acme/todo.md")).why, "/projects/acme/todo.md cannot be read: Permission denied.")
|
||||
self.assertIn("L 'x'", planned(TODO.replace("| 2 | 2 | 3 | 5 |", "| x | 2 | 3 | 5 |"), CUT, "origin/main", BRANCH).why)
|
||||
self.assertIn("details cannot be read", planned(TODO + "```\n", CUT, "origin/main", BRANCH).text)
|
||||
|
||||
def test_tells_a_plan_with_no_items_table_from_one_whose_table_holds_no_item(self):
|
||||
without = planned("", CUT, "origin/main").why
|
||||
without = planned("", CUT, "origin/main", BRANCH).why
|
||||
self.assertIn("origin/main", without)
|
||||
self.assertIn("no items table", without)
|
||||
self.assertNotIn("cannot be read", without)
|
||||
empty = planned(EMPTY, LastCut(None, "", 4, []), "origin/main").why
|
||||
empty = planned(EMPTY, LastCut(None, "", 4, []), "origin/main", BRANCH).why
|
||||
self.assertIn("holds no item", empty)
|
||||
self.assertNotIn("no items table", empty)
|
||||
|
||||
def test_names_a_release_cut_under_a_dated_heading_as_the_last_cut_on_a_branch_with_no_tag(self):
|
||||
said = planned(EMPTY, LastCut(None, "## 0.0.1 - 2026-10-03\n", 0, []), "origin/main").why
|
||||
said = planned(EMPTY, LastCut(None, "## 0.0.1 - 2026-10-03\n", 0, []), "origin/main", BRANCH).why
|
||||
self.assertIn("the next release after the last cut, 0.0.1 (dated in CHANGELOG.md)", said)
|
||||
|
||||
def test_says_the_tags_cannot_be_read_with_gits_reason_and_names_no_cut(self):
|
||||
said = planned(EMPTY, LastCut(Failure("git exited 128: not a git repository"), "", 4, []), "origin/main").why
|
||||
said = planned(EMPTY, LastCut(Failure("git exited 128: not a git repository"), "", 4, []), "origin/main", BRANCH).why
|
||||
self.assertIn("origin/main's tags cannot be read: git exited 128: not a git repository.", said)
|
||||
self.assertIn("Find the next release yourself.", said)
|
||||
self.assertNotIn("no release is cut yet", said)
|
||||
|
||||
def test_names_the_start_as_the_last_cut_where_nothing_is_cut(self):
|
||||
said = planned(EMPTY, LastCut(None, "", 4, [TODO]), "origin/main").why
|
||||
said = planned(EMPTY, LastCut(None, "", 4, [TODO]), "origin/main", BRANCH).why
|
||||
self.assertIn("release 0.2.0, the next after the start, since no release is cut yet,", said)
|
||||
self.assertIn("has landed yet.", said)
|
||||
self.assertIn("since the cut.", planned(EMPTY, LastCut(None, "## 0.1.0 - 2026-10-03\n", 4, [TODO]), "origin/main").why)
|
||||
self.assertIn("since the cut.", planned(EMPTY, LastCut(None, "## 0.1.0 - 2026-10-03\n", 4, [TODO]), "origin/main", BRANCH).why)
|
||||
|
||||
def test_finds_the_release_after_the_last_cut_finished_or_to_be_planned_where_the_plan_holds_no_item_for_it(self):
|
||||
named = "release 0.2.0, the next after the last cut, v0.1.0"
|
||||
@@ -556,24 +557,24 @@ class Plans(unittest.TestCase):
|
||||
)
|
||||
for todo, commits, todos, reviewed, fact, release in cases:
|
||||
with self.subTest(todo=todo, commits=commits, todos=todos, reviewed=reviewed):
|
||||
why = planned(todo, LastCut("v0.1.0", "", commits, todos, reviewed), "origin/main").why
|
||||
why = planned(todo, LastCut("v0.1.0", "", commits, todos, reviewed), "origin/main", BRANCH).why
|
||||
self.assertIn(fact, why)
|
||||
self.assertIn(release, why)
|
||||
|
||||
def test_says_what_todo_md_named_since_the_last_cut_cannot_be_read(self):
|
||||
self.assertIn("cannot be read", planned(LATER, LastCut("v0.1.0", "", 4, Failure("log unreadable")), "origin/main").why)
|
||||
self.assertIn("cannot be read", planned(LATER, LastCut("v0.1.0", "", 4, Failure("log unreadable")), "origin/main", BRANCH).why)
|
||||
|
||||
def test_takes_the_earliest_release_where_no_earlier_one_was_named_since_the_last_cut(self):
|
||||
self.assertEqual(planned(LATER, LastCut("v0.1.0", "", 4, [LATER]), "origin/main").first.id, 9)
|
||||
self.assertEqual(planned(LATER, LastCut("v0.1.0", "", 4, [LATER]), "origin/main", BRANCH).first.id, 9)
|
||||
|
||||
def test_says_the_plan_files_items_under_a_release_already_cut(self):
|
||||
why = planned(TODO, LastCut("v0.2.0", "", 4, []), "origin/main").why
|
||||
why = planned(TODO, LastCut("v0.2.0", "", 4, []), "origin/main", BRANCH).why
|
||||
self.assertIn("release 0.2.0", why)
|
||||
self.assertIn("v0.2.0", why)
|
||||
self.assertIn("not after", why)
|
||||
|
||||
def test_takes_an_item_without_a_detail_as_its_tagline_alone(self):
|
||||
self.assertEqual(planned(TODO[:TODO.index("## Details")], CUT, "origin/main").text, "**Do the next thing.**")
|
||||
self.assertEqual(planned(TODO[:TODO.index("## Details")], CUT, "origin/main", BRANCH).text, "**Do the next thing.**")
|
||||
|
||||
|
||||
class Gathering(unittest.TestCase):
|
||||
|
||||
@@ -17,6 +17,7 @@ from deploy_release import forge
|
||||
from chunk_preflight.choices import forge_of
|
||||
from release_plan.todo_table import items
|
||||
from release_plan.release import newest_tag, Release, version
|
||||
from project_config import templates
|
||||
|
||||
|
||||
def cut(clone: str, checkout: str) -> str | Failure:
|
||||
@@ -109,8 +110,8 @@ def same_origin(clone: str, checkout: str) -> Failure | None:
|
||||
|
||||
def ready_release(clone: str, ref: str) -> Release | Failure:
|
||||
"""The next release, as chunk-preflight works it out, where it is ready to cut: it holds no item in todo.md, its release review has landed and changes are unreleased."""
|
||||
# No project's config names the clone, so its changelog is read at the fixed path, on ref like the plan.
|
||||
plan = default_plan(clone, ref, "todo.md", FileStore(pathlib.Path(clone, "CHANGELOG.md"), "CHANGELOG.md"))
|
||||
# No project's config names the clone, so its changelog is read at the fixed path, on ref like the plan, and its titles as they stand.
|
||||
plan = default_plan(clone, ref, "todo.md", FileStore(pathlib.Path(clone, "CHANGELOG.md"), "CHANGELOG.md"), templates.BARE)
|
||||
found = items(plan.todo) if isinstance(plan.todo, str) else plan.todo
|
||||
if isinstance(found, Failure):
|
||||
return Failure(f"todo.md on {ref} cannot be read: {found.reason}")
|
||||
|
||||
@@ -161,7 +161,6 @@ import typing
|
||||
|
||||
from git_cli.git_repo import branch_titles, default_branch, git, top
|
||||
from review_rules.round_titles import cap, CAP, RELEASE_REVIEW_CAP, round_counts
|
||||
from project_config.main import commit_title
|
||||
from failure import Failure
|
||||
from review_rules.comprehension_history import FLOOR
|
||||
from larv_review.history_changes import history_changes
|
||||
@@ -175,7 +174,7 @@ from larv_review.plan import plan_reasons
|
||||
from larv_review.scoring_setup import prepare_scoring
|
||||
from larv_review.history_commands import read_agreement, read_places, record_ruling, record_scoring
|
||||
from larv_review.reviewer_header import reviewer_header
|
||||
from project_config import templates
|
||||
from project_config.main import title_templates
|
||||
|
||||
|
||||
class Command(typing.NamedTuple):
|
||||
@@ -315,8 +314,10 @@ def round_count(default: str) -> Failure | None:
|
||||
titles = branch_titles(default)
|
||||
if isinstance(titles, Failure):
|
||||
return titles
|
||||
template = commit_title(None, pathlib.Path.home())
|
||||
for name, count in round_counts([templates.summary_of(template, title) for title in titles]).items():
|
||||
templates = title_templates(None, pathlib.Path.home())
|
||||
if isinstance(templates, Failure):
|
||||
return templates
|
||||
for name, count in round_counts([templates.summary(title) for title in titles]).items():
|
||||
print(f"{name}: {count}{cap_note(count, cap(name)) if name in PASSES else ', not a pass: check the commit title'}")
|
||||
return None
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import pathlib
|
||||
|
||||
from release_plan.release_standing import Cut, default_plan, LastCut, next_release, Unknown
|
||||
from release_plan.release_standing import Cut, LastCut, next_release, project_plan, Unknown
|
||||
from failure import Failure
|
||||
from larv_review.scoring import is_floor_item
|
||||
from release_plan.todo_table import Item, items, NoItemsTable, renames
|
||||
@@ -75,7 +75,7 @@ def plan_reasons(ref: str, ids: list[int] | None, home: pathlib.Path) -> list[st
|
||||
return decisions
|
||||
if OPTED_OUT.search(decisions):
|
||||
return []
|
||||
held = default_plan(checkout, ref, config.place("plan"), stores.store(config, "changelog"), title=config.commit_title)
|
||||
held = project_plan(config, ref, checkout)
|
||||
before = held.todo
|
||||
if isinstance(before, Failure):
|
||||
return before
|
||||
|
||||
@@ -4,16 +4,15 @@ import pathlib
|
||||
|
||||
from git_cli.git_repo import branch_titles, git, top
|
||||
from review_rules.round_titles import cap, round_counts
|
||||
from project_config.main import commit_title, located
|
||||
from failure import Failure
|
||||
from chunk_preflight.choices import forge_of
|
||||
from larv_review.history_commands import history_file, places_report
|
||||
from record_store.stores import local_file, store
|
||||
from project_config.main import located, title_templates
|
||||
from review_rules.review_folder import made_review_folder
|
||||
from deploy_release.forge import open_pull, runner
|
||||
from review_rules.reviewer_context import principles_line, starts_bare
|
||||
from review_rules.review_passes import REVIEWERS
|
||||
from project_config import templates
|
||||
|
||||
# The passes whose reviewer is given the places: skills/larv-review/SKILL.md → "Comprehension check" → "Places".
|
||||
TAKE_PLACES = ("architecture", "stability")
|
||||
@@ -76,8 +75,10 @@ def reviewer_header(default: str, pass_: str, rerun: bool, home: pathlib.Path) -
|
||||
titles = branch_titles(default)
|
||||
if isinstance(titles, Failure):
|
||||
return titles
|
||||
template = commit_title(None, home)
|
||||
round_ = unanswered_round([templates.summary_of(template, title) for title in titles], pass_)
|
||||
templates = title_templates(None, home)
|
||||
if isinstance(templates, Failure):
|
||||
return templates
|
||||
round_ = unanswered_round([templates.summary(title) for title in titles], pass_)
|
||||
if isinstance(round_, Failure):
|
||||
return round_
|
||||
found = [top(), *(git(*args) for args in (["symbolic-ref", "--short", "HEAD"], ["rev-parse", "--short", "HEAD"], ["merge-base", "HEAD", default]))]
|
||||
|
||||
@@ -1171,6 +1171,12 @@ class LarvReviewTool(unittest.TestCase):
|
||||
self.assertEqual(self.header_line("Pass:", "prose"), "Pass: prose, round 2.")
|
||||
self.assertIn("prose: 1\n", self.run_tool("round-count").stdout)
|
||||
|
||||
def test_round_count_fails_naming_the_fault_of_a_config_it_cannot_read(self):
|
||||
self.config.write_text(PROJECT_CONFIG + 'commit-title = "PAY-{id}"\n')
|
||||
ran = self.run_tool("round-count")
|
||||
self.assertEqual((ran.returncode, ran.stdout), (1, ""))
|
||||
self.assertIn("`commit-title` is 'PAY-{id}'", ran.stderr)
|
||||
|
||||
def test_reviewer_header_names_the_goals_file_the_projects_config_sets(self):
|
||||
self.config.write_text(PROJECT_CONFIG.replace('"checkout:README.md"', '"folder:goals.md"'))
|
||||
self.assertEqual(self.header_line("Goals and audience:", "principles"), f"Goals and audience: {self.config.parent}/goals.md")
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
import pathlib
|
||||
import typing
|
||||
|
||||
from release_plan.release_standing import default_plan, DefaultPlan, held_at, UNSEEN_RELEASES
|
||||
from git_cli.git_repo import default_ref
|
||||
from release_plan.release_standing import DefaultPlan, held_at, project_plan, UNSEEN_RELEASES
|
||||
from loop_effects.effects import Effects, say
|
||||
from failure import Failure
|
||||
from loop_claude.routing import first_route, kept, routed_item
|
||||
@@ -15,7 +15,6 @@ from loop_claude.cycle import prompts
|
||||
from model_routing.route import Route, route_from
|
||||
from model_routing.ladder import Rung
|
||||
from claude_code.session import session_open, transcript_file
|
||||
from record_store.stores import store
|
||||
|
||||
# Seconds routing waits for origin to name its default branch, asked only where the checkout records none; past them, the chunk runs on the project's rung.
|
||||
ORIGIN_TIMEOUT = 60
|
||||
@@ -80,7 +79,7 @@ def fetched_plan(loop: Loop) -> DefaultPlan | Failure:
|
||||
if config.tracked("plan") is None:
|
||||
say(UNSEEN_RELEASES, loop.effects)
|
||||
ref = default_ref(loop.root, ORIGIN_TIMEOUT, run=loop.effects.git)
|
||||
return ref if isinstance(ref, Failure) else default_plan(loop.root, ref, config.place("plan"), store(config, "changelog"), loop.effects.git, title=config.commit_title)
|
||||
return ref if isinstance(ref, Failure) else project_plan(config, ref, loop.root, loop.effects.git)
|
||||
|
||||
|
||||
def plan_item(plan: DefaultPlan | Failure, effects: Effects) -> Item | None:
|
||||
|
||||
@@ -831,19 +831,20 @@ class RoutingCheck(unittest.TestCase):
|
||||
self.assertEqual(self.check(FakeEffects()), (None, ""))
|
||||
self.assertFalse((self.root / "routing-figures.md").exists())
|
||||
self.chunks(6, 1, "other")
|
||||
self.assertEqual(self.check(FakeEffects(on_terminal=False, git=[UNREAD] * 4))[0], None)
|
||||
self.assertEqual(self.check(FakeEffects(on_terminal=False, git=[UNREAD] * 6))[0], None)
|
||||
self.assertIn("at cycle 21 across", (self.root / "routing-figures.md").read_text())
|
||||
|
||||
def test_reads_each_projects_history_through_the_loops_git_and_names_each_it_cannot_read(self):
|
||||
self.chunks(5, 4)
|
||||
fake = FakeEffects(on_terminal=False, git=[UNREAD] * 2)
|
||||
fake = FakeEffects(on_terminal=False, git=[UNREAD] * 3)
|
||||
self.check(fake)
|
||||
self.assertEqual(fake.made("git"), [["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"], ["remote"]])
|
||||
located = ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"]
|
||||
self.assertEqual(fake.made("git"), [located, located, ["remote"]], "the config is located for its title templates, then for where it keeps the plan")
|
||||
self.assertIn("## Default branches unread\n\n- log: not a git repository\n", (self.root / "routing-figures.md").read_text())
|
||||
|
||||
def test_hands_the_terminal_over_once_for_each_new_call(self):
|
||||
self.chunks(5, 4)
|
||||
fake = FakeEffects(on_terminal_claude=[0], git=[UNREAD] * 2)
|
||||
fake = FakeEffects(on_terminal_claude=[0], git=[UNREAD] * 3)
|
||||
stop, said = self.check(fake)
|
||||
self.assertIsNone(stop)
|
||||
call = "Explore subagents' reports took more of the worker's context than their searches would have."
|
||||
@@ -856,13 +857,13 @@ class RoutingCheck(unittest.TestCase):
|
||||
self.assertEqual(fake.terminal_folders, [str(self.home / "code" / "claude-config")], "the development clone, since ~/.claude holds only a release")
|
||||
self.assertIn("Record what they decide in this checkout, the development clone", args[6])
|
||||
self.assertIsNone(state.mark_measured(self.root, 0))
|
||||
self.assertEqual(self.check(FakeEffects(git=[UNREAD] * 2))[0], None)
|
||||
self.assertEqual(self.check(FakeEffects(git=[UNREAD] * 3))[0], None)
|
||||
self.assertNotIn(call, self.check(FakeEffects())[1])
|
||||
|
||||
def test_stamps_the_figures_and_the_calls_raised_when_it_measures(self):
|
||||
self.chunks(5, 4)
|
||||
(self.root / "routing-calls-raised.md").write_text("# Routing calls raised\n\n- 2026-10-14T10:02:00Z Reset\n")
|
||||
self.check(FakeEffects(on_terminal_claude=[0], git=[UNREAD] * 2))
|
||||
self.check(FakeEffects(on_terminal_claude=[0], git=[UNREAD] * 3))
|
||||
figures = (self.root / "routing-figures.md").read_text()
|
||||
self.assertIn(f"Measured {utc(NOW)}, at cycle 20 across", figures)
|
||||
self.assertIn("that finished after the reset of 2026-10-14T10:02:00Z", figures)
|
||||
@@ -875,11 +876,11 @@ class RoutingCheck(unittest.TestCase):
|
||||
|
||||
def test_goes_on_off_a_terminal_and_raises_the_call_again_next_time(self):
|
||||
self.chunks(5, 4)
|
||||
stop, said = self.check(FakeEffects(on_terminal=False, git=[UNREAD] * 2))
|
||||
stop, said = self.check(FakeEffects(on_terminal=False, git=[UNREAD] * 3))
|
||||
self.assertIsNone(stop)
|
||||
self.assertIn("Not on a terminal: the calls are raised again at the next measurement.", said)
|
||||
self.assertIsNone(state.mark_measured(self.root, 0))
|
||||
self.assertIn("Not on a terminal", self.check(FakeEffects(on_terminal=False, git=[UNREAD] * 2))[1])
|
||||
self.assertIn("Not on a terminal", self.check(FakeEffects(on_terminal=False, git=[UNREAD] * 3))[1])
|
||||
|
||||
def test_leaves_the_measuring_to_a_loop_holding_the_lock(self):
|
||||
self.chunks(5, 4)
|
||||
@@ -888,7 +889,7 @@ class RoutingCheck(unittest.TestCase):
|
||||
|
||||
def test_stops_when_claude_cannot_start_for_the_calls(self):
|
||||
self.chunks(5, 4)
|
||||
stop, _ = self.check(FakeEffects(on_terminal_claude=[OSError(2, "No such file or directory")], git=[UNREAD] * 2))
|
||||
stop, _ = self.check(FakeEffects(on_terminal_claude=[OSError(2, "No such file or directory")], git=[UNREAD] * 3))
|
||||
self.assertEqual(stop, Stop(1, f"could not start claude for the routing calls in {self.home / 'code' / 'claude-config'}, the setup's development clone: No such file or directory"))
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root writes into a read-only directory")
|
||||
@@ -897,7 +898,7 @@ class RoutingCheck(unittest.TestCase):
|
||||
(self.root / "routing-figures.lock").touch()
|
||||
self.root.chmod(0o555)
|
||||
self.addCleanup(self.root.chmod, 0o755)
|
||||
stop, said = self.check(FakeEffects(git=[UNREAD] * 2))
|
||||
stop, said = self.check(FakeEffects(git=[UNREAD] * 3))
|
||||
self.assertIsNone(stop)
|
||||
self.assertIn("routing figures: could not write", said)
|
||||
|
||||
|
||||
+16
-10
@@ -35,17 +35,21 @@ Four optional settings say how the project writes, for a project whose owners do
|
||||
~/.claude/CLAUDE.md does:
|
||||
|
||||
language = "Swedish"
|
||||
commit-title = "PAY-{id} - {summary}"
|
||||
pull-request-title = "PAY-{id} - {summary}"
|
||||
branch = "feature/PAY-{id}"
|
||||
commit-title = "[{id}] {summary}"
|
||||
pull-request-title = "[{id}] {summary}"
|
||||
branch = "feature/{id}"
|
||||
|
||||
`language` names the language of the project's prose by its English name; left out, it is English.
|
||||
The others are templates. {summary} is the one line that says what a commit or pull request does,
|
||||
and {id} is the ID of the chunk's first plan item. A title template holds {summary} once and {id}
|
||||
at most once; left out, it is "{summary}". `branch` holds {id} once, among letters, digits and
|
||||
at most once, never directly beside {summary}, with no space at its start or end and no control
|
||||
character; left out, it is "{summary}". `branch` holds {id} once, among letters, digits and
|
||||
. _ / -; left out, it is "item-{id}". A template has no way to write a literal { or }.
|
||||
A title must fit its template only on a branch that fits `branch`. On any other branch, as for a
|
||||
chunk with no plan item, such as a release review, it may be the bare summary. A tool that reads
|
||||
a title for its summary tries `commit-title`, then `pull-request-title`, then takes the title whole.
|
||||
`project-config <setting>` prints each one's value, and the full listing shows it only where the
|
||||
config sets it to something else than it is when left out.
|
||||
config changes it from what it is when left out.
|
||||
|
||||
Exit 1, naming each fault on stderr, where no config names the checkout, or its config leaves out a
|
||||
setting, names an unknown one, misspells a path, a language or a template, or sets `wait-for-approval` to anything but true or
|
||||
@@ -54,7 +58,7 @@ false, and where `env-file` is asked for and not set. No path setting has a defa
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
from project_config.settings import CONFIG, ENV_FILE, load, OPTIONAL, ProjectConfig, SETTINGS, WAIT_FOR_APPROVAL
|
||||
from project_config.settings import CONFIG, ENV_FILE, load, OPTIONAL, ProjectConfig, SETTINGS, Unnamed, WAIT_FOR_APPROVAL
|
||||
from failure import Failure
|
||||
from git_cli.git_repo import git, Git
|
||||
from project_config import templates
|
||||
@@ -91,17 +95,19 @@ def located(directory: str | None, home: pathlib.Path, run: Git = git) -> Projec
|
||||
"""The config under home of the checkout that holds directory, else the current directory."""
|
||||
found = run("rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir", cwd=directory)
|
||||
if isinstance(found, Failure):
|
||||
return found
|
||||
return Unnamed(found.reason)
|
||||
if len(lines := found.splitlines()) != 2:
|
||||
return Failure(f"git rev-parse printed {found!r}, not a checkout's top folder and git directory on two lines")
|
||||
# The common dir is the main checkout's .git, whichever worktree runs this.
|
||||
return load(pathlib.Path(lines[0]), pathlib.Path(lines[1]).parent, home)
|
||||
|
||||
|
||||
def commit_title(directory: str | None, home: pathlib.Path, run: Git = git) -> str:
|
||||
"""The `commit-title` template of the project whose checkout holds directory, else the current directory. A bare summary where no config names the checkout or its config cannot be read, as in a third party's clone, so every title there is read as it stands."""
|
||||
def title_templates(directory: str | None, home: pathlib.Path, run: Git = git) -> templates.Titles | Failure:
|
||||
"""The title templates of the project whose checkout holds directory, else the current directory. Bare summaries where no config names a checkout there, as in a third party's clone, so every title is read as it stands. A Failure where a config is faulty or cannot be read: read bare, a templated project's round titles would count for nothing."""
|
||||
config = located(directory, home, run)
|
||||
return templates.TITLE if isinstance(config, Failure) else config.commit_title
|
||||
if isinstance(config, Unnamed):
|
||||
return templates.BARE
|
||||
return config if isinstance(config, Failure) else config.titles
|
||||
|
||||
|
||||
def project() -> ProjectConfig | Failure:
|
||||
|
||||
@@ -19,18 +19,23 @@ SPELLING = '"checkout:<path>" for a path in the checkout, "folder:<path>" for on
|
||||
ENV_FILE = "env-file"
|
||||
# The optional boolean setting: whether `chunk-pr merge` waits for a human's approval of the pull request. False where left out.
|
||||
WAIT_FOR_APPROVAL = "wait-for-approval"
|
||||
# The optional text settings, each with what it holds where left out and the check that says why a value is no good. `language` is the language the project's prose is written in, by its English name. The others are templates, as `templates` says.
|
||||
# The optional text settings. `language` is the language the project's prose is written in, by its English name. The others are templates, as `templates` says.
|
||||
LANGUAGE = "language"
|
||||
COMMIT_TITLE = "commit-title"
|
||||
PULL_REQUEST_TITLE = "pull-request-title"
|
||||
BRANCH = "branch"
|
||||
OPTIONAL = (ENV_FILE, WAIT_FOR_APPROVAL, LANGUAGE, COMMIT_TITLE, PULL_REQUEST_TITLE, BRANCH)
|
||||
OPTIONAL = (BRANCH, COMMIT_TITLE, ENV_FILE, LANGUAGE, PULL_REQUEST_TITLE, WAIT_FOR_APPROVAL)
|
||||
OUTSIDE = "a path that starts with / or ~/ and lies outside the checkout and the config's folder, so that no git remote receives the credentials"
|
||||
|
||||
# Where a project keeps a file, for a tool that reads it at a commit: a path from the checkout's top, as git names it; or, outside the checkout, the file itself, which the tool reads as it stands, since the checkout's commits hold no version of it.
|
||||
Place = str | pathlib.Path
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class Unnamed(Failure):
|
||||
"""No config names a checkout here: none names the one asked for, or git finds no checkout. A reader of titles takes them bare there, as in a third party's clone; a config that is faulty or cannot be read is a plain Failure."""
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class ProjectConfig:
|
||||
"""folder is `~/.claude-projects/<key>`, top is the worktree that asked, and paths holds each of SETTINGS as an absolute path."""
|
||||
@@ -51,6 +56,10 @@ class ProjectConfig:
|
||||
"""Each text setting's value, by the name the config gives it."""
|
||||
return {LANGUAGE: self.language, COMMIT_TITLE: self.commit_title, PULL_REQUEST_TITLE: self.pull_request_title, BRANCH: self.branch}
|
||||
|
||||
@property
|
||||
def titles(self) -> templates.Titles:
|
||||
return templates.Titles(self.commit_title, self.pull_request_title)
|
||||
|
||||
def tracked(self, setting: str) -> str | None:
|
||||
"""setting's path from top, as git names a file in a commit; None where the config puts it outside the checkout, whose commits hold no version of it."""
|
||||
path = self.paths[setting]
|
||||
@@ -74,7 +83,7 @@ def load(top: pathlib.Path, main: pathlib.Path, home: pathlib.Path) -> ProjectCo
|
||||
if config[0].resolve() == main.resolve():
|
||||
named.append((file, config[1]))
|
||||
if not named:
|
||||
return Failure(f"no config names the checkout {main}: write ~/{PROJECTS}/<key>/{CONFIG}, as `project-config --help` shows")
|
||||
return Unnamed(f"no config names the checkout {main}: write ~/{PROJECTS}/<key>/{CONFIG}, as `project-config --help` shows")
|
||||
if len(named) > 1:
|
||||
return Failure(f"{' and '.join(str(file) for file, _ in named)} each name the checkout {main}; only one config may")
|
||||
file, values = named[0]
|
||||
@@ -99,7 +108,7 @@ def load(top: pathlib.Path, main: pathlib.Path, home: pathlib.Path) -> ProjectCo
|
||||
def language_fault(value: object) -> str | None:
|
||||
"""Why value names no language; None where it does. Only words, since the name is quoted to every worker and reviewer as an instruction."""
|
||||
named = isinstance(value, str) and re.fullmatch(r"[^\W\d_]+(?:[ -][^\W\d_]+)*", value)
|
||||
return None if named else 'not a language\'s English name, such as "Swedish"'
|
||||
return None if named else 'not a language\'s English name in words of letters, such as "Swedish" or "Brazilian Portuguese"'
|
||||
|
||||
|
||||
def lies_in(path: pathlib.Path, *places: pathlib.Path) -> bool:
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
"""The templates a project's config names for its commit titles, pull request titles and branches.
|
||||
|
||||
A template is literal text around two placeholders: `{id}`, the ID of the chunk's first plan item, and `{summary}`, the one line that says what the commit or pull request does. Three readers, seated as the human who writes the config, picked that spelling from four candidates. A template has no escape for a literal brace: one is a fault, which keeps a misspelt placeholder such as `{ID}` out of every title."""
|
||||
A template is literal text around two placeholders: `{id}`, the ID of the chunk's first plan item, and `{summary}`, the one line that says what the commit or pull request does. A template has no escape for a literal brace: one is a fault, which keeps a misspelt placeholder such as `{ID}` out of every title."""
|
||||
import dataclasses
|
||||
import re
|
||||
|
||||
ID = "{id}"
|
||||
@@ -16,20 +17,27 @@ BRANCH_TEXT = re.compile(r"[A-Za-z0-9._/-]+")
|
||||
def title_fault(template: object) -> str | None:
|
||||
"""Why template is no title template; None where it is one."""
|
||||
if not isinstance(template, str):
|
||||
return f"not text such as \"PAY-{ID} - {SUMMARY}\""
|
||||
return f"not text such as \"[{ID}] {SUMMARY}\""
|
||||
if "\n" in template:
|
||||
return "not one line"
|
||||
if re.search(r"[\x00-\x1f\x7f-\x9f]", template):
|
||||
return "with a control character"
|
||||
# The tools match a title with the space around it stripped, so no title would fit.
|
||||
if template != template.strip():
|
||||
return "with a space at its start or end"
|
||||
if template.count(SUMMARY) != 1:
|
||||
return f"without exactly one {SUMMARY}"
|
||||
if template.count(ID) > 1:
|
||||
return f"with more than one {ID}"
|
||||
if ID + SUMMARY in template or SUMMARY + ID in template:
|
||||
return f"with {ID} right beside {SUMMARY}, so no text says where one ends and the other starts"
|
||||
return stray_brace(template)
|
||||
|
||||
|
||||
def branch_fault(template: object) -> str | None:
|
||||
"""Why template is no branch template; None where it is one. A branch needs the ID, or two chunks would share one."""
|
||||
if not isinstance(template, str):
|
||||
return f"not text such as \"feature/PAY-{ID}\""
|
||||
return f"not text such as \"feature/{ID}\""
|
||||
if template.count(ID) != 1 or SUMMARY in template:
|
||||
return f"without exactly one {ID}, or with a {SUMMARY}"
|
||||
branch = template.replace(ID, "1")
|
||||
@@ -48,6 +56,11 @@ def branch_of(template: str, id_: int) -> str:
|
||||
return template.replace(ID, str(id_))
|
||||
|
||||
|
||||
def branch_fits(template: str, branch: str) -> bool:
|
||||
"""Whether branch is one branch_of makes from template: a chunk's branch whose first plan item gave it its ID. A chunk without a plan item, such as a release review, is on a branch that doesn't fit."""
|
||||
return re.fullmatch(re.escape(template).replace(re.escape(ID), "[0-9]+"), branch) is not None
|
||||
|
||||
|
||||
def pattern(template: str) -> re.Pattern[str]:
|
||||
"""What a title made from template looks like: its literal text, digits for the ID, and a summary that opens and ends with something other than a space."""
|
||||
shapes = {ID: "[0-9]+", SUMMARY: r"(?P<summary>\S(?:.*\S)?)"}
|
||||
@@ -62,3 +75,18 @@ def summary_of(template: str, title: str) -> str:
|
||||
"""title's summary. A title that doesn't fit template is its own summary, so a commit from before the config named the template reads as it always did."""
|
||||
found = pattern(template).fullmatch(title)
|
||||
return found["summary"] if found else title
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class Titles:
|
||||
"""A project's two title templates, `commit-title` and `pull-request-title`, for a tool that reads a commit's title as its summary."""
|
||||
commit: str
|
||||
pull_request: str
|
||||
|
||||
def summary(self, title: str) -> str:
|
||||
"""title's summary: read through commit, and where that leaves the title whole, through pull_request, since a squash merge titles the default branch's commit as its pull request. A title that fits neither is its own summary."""
|
||||
return next((summary for template in (self.commit, self.pull_request) if (summary := summary_of(template, title)) != title), title)
|
||||
|
||||
|
||||
# The templates of a project whose config names none, and of a checkout no config names: every title is its own summary.
|
||||
BARE = Titles(TITLE, TITLE)
|
||||
|
||||
@@ -8,10 +8,11 @@ import unittest.mock
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from project_config.main import commit_title
|
||||
from project_config.settings import env_files, held, load, OUTSIDE, ProjectConfig, SETTINGS
|
||||
from project_config.settings import env_files, held, load, OUTSIDE, ProjectConfig, SETTINGS, Unnamed
|
||||
from failure import Failure
|
||||
from test_env import isolated_env
|
||||
from project_config.main import title_templates
|
||||
from project_config.templates import Titles
|
||||
|
||||
TOOL = pathlib.Path(__file__).resolve().parents[1] / "project-config"
|
||||
|
||||
@@ -231,9 +232,22 @@ class LoadTest(ConfigCase):
|
||||
assert isinstance(found, Failure), found
|
||||
self.assertIn(named, found.reason)
|
||||
|
||||
def test_a_language_of_more_than_words_fails_saying_what_is_accepted(self) -> None:
|
||||
folder = self.write("acme", CLIENT + 'language = "Chinese (Simplified)"\n')
|
||||
found = load(self.checkout, self.checkout, self.home)
|
||||
assert isinstance(found, Failure), found
|
||||
self.assertIn("`language` is 'Chinese (Simplified)', not a language's English name in words of letters, such as \"Swedish\" or \"Brazilian Portuguese\"", found.reason)
|
||||
(folder / "config.toml").write_text(CLIENT + 'language = "Brazilian Portuguese"\n')
|
||||
self.assertIsInstance(load(self.checkout, self.checkout, self.home), ProjectConfig)
|
||||
|
||||
def test_a_checkout_no_config_names_fails_as_unnamed_and_a_faulty_config_does_not(self) -> None:
|
||||
self.assertIsInstance(load(self.checkout, self.checkout, self.home), Unnamed)
|
||||
self.write("acme", CLIENT + "language = 3\n")
|
||||
self.assertNotIsInstance(load(self.checkout, self.checkout, self.home), Unnamed)
|
||||
|
||||
def test_the_failure_for_a_misplaced_env_file_and_a_missing_setting_names_both_and_lists_every_setting(self) -> None:
|
||||
folder = self.write("acme", "".join(line + "\n" for line in CLIENT.splitlines() if not line.startswith("plan")) + 'env-file = "checkout:.env"\n')
|
||||
self.assertEqual(self.failure(), f"{folder / 'config.toml'}: `plan` is missing; `env-file` is 'checkout:.env', not {OUTSIDE}. The settings are {', '.join(SETTINGS)}, and optionally env-file, wait-for-approval, language, commit-title, pull-request-title and branch.")
|
||||
self.assertEqual(self.failure(), f"{folder / 'config.toml'}: `plan` is missing; `env-file` is 'checkout:.env', not {OUTSIDE}. The settings are {', '.join(SETTINGS)}, and optionally branch, commit-title, env-file, language, pull-request-title and wait-for-approval.")
|
||||
|
||||
def test_two_configs_naming_one_checkout_fail_naming_both(self) -> None:
|
||||
self.write("acme", CLIENT)
|
||||
@@ -257,13 +271,25 @@ class LoadTest(ConfigCase):
|
||||
self.assertIsInstance(load(self.checkout, self.checkout, self.home), ProjectConfig)
|
||||
|
||||
|
||||
class CommitTitleTest(ConfigCase):
|
||||
def test_names_the_configs_template_and_a_bare_summary_where_no_config_names_the_checkout(self) -> None:
|
||||
class TitleTemplatesTest(ConfigCase):
|
||||
def test_names_the_configs_templates_and_bare_summaries_where_no_config_names_the_checkout_or_git_finds_none(self) -> None:
|
||||
subprocess.run(["git", "init", "--quiet", str(self.checkout)], check=True, env=isolated_env())
|
||||
self.assertEqual(commit_title(str(self.checkout), self.home), "{summary}")
|
||||
self.write("acme", CLIENT + 'commit-title = "PAY-{id} - {summary}"\n')
|
||||
self.assertEqual(commit_title(str(self.checkout), self.home), "PAY-{id} - {summary}")
|
||||
self.assertEqual(commit_title(str(self.home), self.home), "{summary}")
|
||||
self.assertEqual(title_templates(str(self.checkout), self.home), Titles("{summary}", "{summary}"))
|
||||
self.write("acme", CLIENT + 'commit-title = "PAY-{id} - {summary}"\npull-request-title = "fix: {summary} (#{id})"\n')
|
||||
self.assertEqual(title_templates(str(self.checkout), self.home), Titles("PAY-{id} - {summary}", "fix: {summary} (#{id})"))
|
||||
self.assertEqual(title_templates(str(self.home), self.home), Titles("{summary}", "{summary}"))
|
||||
|
||||
def test_fails_where_the_checkouts_config_or_any_other_cannot_be_read(self) -> None:
|
||||
subprocess.run(["git", "init", "--quiet", str(self.checkout)], check=True, env=isolated_env())
|
||||
folder = self.write("acme", CLIENT + 'commit-title = "PAY-{id}"\n')
|
||||
faulty = title_templates(str(self.checkout), self.home)
|
||||
assert isinstance(faulty, Failure), faulty
|
||||
self.assertIn("`commit-title` is 'PAY-{id}'", faulty.reason)
|
||||
(folder / "config.toml").write_text(CLIENT)
|
||||
other = self.write("other", "checkout = [")
|
||||
unread = title_templates(str(self.checkout), self.home)
|
||||
assert isinstance(unread, Failure), unread
|
||||
self.assertIn(f"cannot read {other / 'config.toml'}", unread.reason)
|
||||
|
||||
|
||||
class HeldTest(ConfigCase):
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import unittest
|
||||
|
||||
from project_config.templates import branch_fault, branch_of, fits, summary_of, title_fault
|
||||
from project_config.templates import BARE, branch_fault, branch_fits, branch_of, fits, summary_of, title_fault, Titles
|
||||
|
||||
|
||||
class TitleTest(unittest.TestCase):
|
||||
@@ -15,6 +15,14 @@ class TitleTest(unittest.TestCase):
|
||||
assert fault is not None
|
||||
self.assertIn(named, fault)
|
||||
|
||||
def test_a_title_template_that_no_title_fits_or_that_splits_a_title_two_ways_is_a_fault(self) -> None:
|
||||
cases = {"{summary} ": "start or end", " PAY-{id} {summary}": "start or end", "\t{summary}": "control character", "{summary}\r": "control character", "PAY-{id}\x00 {summary}": "control character", "{id}{summary}": "beside", "{summary}{id}": "beside", "PAY-{id}{summary}": "beside"}
|
||||
for template, named in cases.items():
|
||||
with self.subTest(template):
|
||||
fault = title_fault(template)
|
||||
assert fault is not None
|
||||
self.assertIn(named, fault)
|
||||
|
||||
def test_a_branch_template_holds_one_id_and_names_a_branch_git_accepts(self) -> None:
|
||||
for template in ("item-{id}", "feature/PAY-{id}", "{id}"):
|
||||
with self.subTest(template):
|
||||
@@ -45,6 +53,27 @@ class TitleTest(unittest.TestCase):
|
||||
self.assertFalse(fits(template, title))
|
||||
self.assertEqual(summary_of(template, title), title)
|
||||
|
||||
def test_a_branch_fits_its_template_where_digits_stand_for_the_id(self) -> None:
|
||||
for template, branch in (("item-{id}", "item-357"), ("feature/PAY-{id}", "feature/PAY-7"), ("{id}", "12")):
|
||||
with self.subTest(branch):
|
||||
self.assertTrue(branch_fits(template, branch))
|
||||
for template, branch in (("item-{id}", "release-review-0.3.0"), ("item-{id}", "main"), ("item-{id}", "item-"), ("item-{id}", "item-7-more"), ("a.b-{id}", "axb-7"), ("item-{id}", "")):
|
||||
with self.subTest(branch):
|
||||
self.assertFalse(branch_fits(template, branch))
|
||||
|
||||
def test_reads_a_title_through_the_commit_template_then_the_pull_request_template_then_as_its_own_summary(self) -> None:
|
||||
cases = {
|
||||
(Titles("{summary}", "PAY-{id} - {summary}"), "PAY-7 - Release review of 0.3.0"): "Release review of 0.3.0",
|
||||
(Titles("PAY-{id} - {summary}", "{summary}"), "PAY-7 - Release review of 0.3.0"): "Release review of 0.3.0",
|
||||
(Titles("PAY-{id} - {summary}", "fix: {summary} (#{id})"), "fix: Drop item 6: moot (#7)"): "Drop item 6: moot",
|
||||
(Titles("PAY-{id} - {summary}", "fix: {summary} (#{id})"), "PAY-7 - Drop item 6: moot"): "Drop item 6: moot",
|
||||
(Titles("PAY-{id} - {summary}", "fix: {summary} (#{id})"), "From before the templates"): "From before the templates",
|
||||
(BARE, "PAY-7 - Tests"): "PAY-7 - Tests",
|
||||
}
|
||||
for (titles, title), summary in cases.items():
|
||||
with self.subTest(title):
|
||||
self.assertEqual(titles.summary(title), summary)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
@@ -36,6 +36,7 @@ from transcript_archive.read import finished_chunks, read_threads
|
||||
from git_cli.git_repo import git
|
||||
from project_config.main import project
|
||||
from transcript_archive.location import project_archive
|
||||
from project_config import templates
|
||||
from text_files.utc_stamp import utc
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
@@ -53,16 +54,15 @@ def main(argv: list[str]) -> int:
|
||||
if len(given) > 1 or given[:1] and given[0].startswith("-"):
|
||||
print(f"unknown arguments {' '.join(given)}; usage: reading-cost [--reset] [record]", file=sys.stderr)
|
||||
return 1
|
||||
checkout = located()
|
||||
config = project()
|
||||
# Given a record, the tool runs without a config, and then knows no worktree names but the ones the default template makes.
|
||||
checkout = located(templates.BRANCH if isinstance(config, Failure) else config.branch)
|
||||
if isinstance(checkout, Failure):
|
||||
return failed(checkout)
|
||||
home = pathlib.Path.home()
|
||||
archive = project_archive(checkout.main_root, home, os.environ)
|
||||
config = project()
|
||||
if not given and isinstance(config, Failure):
|
||||
return failed(config)
|
||||
if not isinstance(config, Failure):
|
||||
checkout = dataclasses.replace(checkout, branch=config.branch)
|
||||
record: RecordStore = FileStore(pathlib.Path(given[0]), None) if given or isinstance(config, Failure) else store(config, "reading-cost")
|
||||
updated = update(record, archive, checkout, str(home), utc(time.time()) if reset else None)
|
||||
if isinstance(updated, Failure):
|
||||
@@ -110,7 +110,8 @@ def failed(failure: Failure) -> int:
|
||||
return 1
|
||||
|
||||
|
||||
def located() -> Checkout | Failure:
|
||||
def located(branch: str) -> Checkout | Failure:
|
||||
"""The checkout that holds the current directory, whose project names each item's worktree by the template branch."""
|
||||
found = git("rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir")
|
||||
if isinstance(found, Failure):
|
||||
return found
|
||||
@@ -121,6 +122,6 @@ def located() -> Checkout | Failure:
|
||||
if isinstance(listed, Failure):
|
||||
return listed
|
||||
# The common dir is the main checkout's .git, whichever worktree runs this.
|
||||
return Checkout(top, str(pathlib.Path(common).parent), frozenset(filter(None, listed.split("\0"))))
|
||||
return Checkout(top, str(pathlib.Path(common).parent), frozenset(filter(None, listed.split("\0"))), branch)
|
||||
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@ class Checkout:
|
||||
main_root: str
|
||||
tracked: frozenset[str]
|
||||
# The project's `branch` template, which names each item's worktree.
|
||||
branch: str = templates.BRANCH
|
||||
branch: str
|
||||
|
||||
|
||||
def measure(threads: list[bytes], checkout: Checkout, home: str) -> Reading | None:
|
||||
|
||||
@@ -14,6 +14,7 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from transcript_archive.write import archive
|
||||
from claude_code.entries import AssistantTurn
|
||||
from project_config.templates import BRANCH
|
||||
from reading_cost.measure import Checkout, Reading
|
||||
from failure import Failure
|
||||
from reading_cost import figures, main, measure
|
||||
@@ -64,7 +65,7 @@ class Measure(unittest.TestCase):
|
||||
said("6", "m5", tokens=100, name="Read", input={"file_path": "/c/p/late.py"}),
|
||||
]
|
||||
subagent = [said("2", "s1", tokens=1, name="Grep", input={"path": "/c/w/src/a.py"}), said("7", "s2", tokens=100, name="Read", input={"file_path": "/c/p/late.py"})]
|
||||
checkout = Checkout("/c/w", "/c/p", frozenset({"README.md", "late.py", "src/a.py", "src/b.py", "x.py"}))
|
||||
checkout = Checkout("/c/w", "/c/p", frozenset({"README.md", "late.py", "src/a.py", "src/b.py", "x.py"}), BRANCH)
|
||||
self.assertEqual(measure.measure([jsonl(worker), jsonl(subagent)], checkout, "/h"), Reading(33, collections.Counter({"src/a.py": 2, "README.md": 1, "src/b.py": 1})))
|
||||
|
||||
def test_counts_only_reads_and_greps_by_their_path_and_a_command_without_a_cwd_from_the_root(self):
|
||||
@@ -74,25 +75,25 @@ class Measure(unittest.TestCase):
|
||||
said("3", "m3", command="cat c/p/b.py", cwd=""),
|
||||
said("4", "m4", command="git commit -m x"),
|
||||
]
|
||||
self.assertEqual(measure.measure([jsonl(worker)], Checkout("/c/p", "/c/p", frozenset({"a.py", "b.py"})), "/h").files, collections.Counter({"b.py": 1}))
|
||||
self.assertEqual(measure.measure([jsonl(worker)], Checkout("/c/p", "/c/p", frozenset({"a.py", "b.py"}), BRANCH), "/h").files, collections.Counter({"b.py": 1}))
|
||||
|
||||
def test_counts_a_file_read_in_the_worktree_chunk_preflight_made_as_the_checkout_s(self):
|
||||
worker = [said("1", "m1", tokens=10, name="Read", input={"file_path": "/c/p-item-7/README.md"}), said("2", "m2", command="git commit -m x")]
|
||||
checkout = Checkout("/c/p-item-7", "/c/p", frozenset({"README.md"}))
|
||||
checkout = Checkout("/c/p-item-7", "/c/p", frozenset({"README.md"}), BRANCH)
|
||||
self.assertEqual(measure.measure([jsonl(worker)], checkout, "/h").files, collections.Counter({"README.md": 1}))
|
||||
|
||||
def test_counts_a_file_read_in_a_worktree_named_by_the_configs_branch_template(self):
|
||||
worker = [said("1", "m1", tokens=10, name="Read", input={"file_path": "/c/p-feature-PAY-7/README.md"}), said("2", "m2", command="git commit -m x")]
|
||||
checkout = Checkout("/c/p-feature-PAY-7", "/c/p", frozenset({"README.md"}), "feature/PAY-{id}")
|
||||
self.assertEqual(measure.measure([jsonl(worker)], checkout, "/h").files, collections.Counter({"README.md": 1}))
|
||||
self.assertEqual(measure.measure([jsonl(worker)], Checkout("/c/p-feature-PAY-7", "/c/p", frozenset({"README.md"})), "/h").files, collections.Counter())
|
||||
self.assertEqual(measure.measure([jsonl(worker)], Checkout("/c/p-feature-PAY-7", "/c/p", frozenset({"README.md"}), BRANCH), "/h").files, collections.Counter())
|
||||
|
||||
def test_measures_nothing_for_a_worker_that_never_committed(self):
|
||||
self.assertIsNone(measure.measure([jsonl([said("1", "m1", command="git log --grep commit")])], Checkout("/c/p", "/c/p", frozenset()), "/h"))
|
||||
self.assertIsNone(measure.measure([jsonl([said("1", "m1", command="echo git commit")])], Checkout("/c/p", "/c/p", frozenset()), "/h"))
|
||||
self.assertIsNone(measure.measure([jsonl([said("1", "m1", command="git log --grep commit")])], Checkout("/c/p", "/c/p", frozenset(), BRANCH), "/h"))
|
||||
self.assertIsNone(measure.measure([jsonl([said("1", "m1", command="echo git commit")])], Checkout("/c/p", "/c/p", frozenset(), BRANCH), "/h"))
|
||||
|
||||
def test_finds_a_commit_behind_git_options(self):
|
||||
self.assertIsNotNone(measure.measure([jsonl([said("1", "m1", command="git -c user.name=t commit -m x")])], Checkout("/c/p", "/c/p", frozenset()), "/h"))
|
||||
self.assertIsNotNone(measure.measure([jsonl([said("1", "m1", command="git -c user.name=t commit -m x")])], Checkout("/c/p", "/c/p", frozenset(), BRANCH), "/h"))
|
||||
|
||||
def test_skips_a_usage_that_is_not_a_count(self):
|
||||
self.assertEqual(measure.tokens_in([AssistantTurn(message_id="m", usage={"input_tokens": "7", "cache_creation_input_tokens": 2})]), 2)
|
||||
@@ -142,10 +143,12 @@ class ReadingCostTool(unittest.TestCase):
|
||||
def git(self, *args):
|
||||
subprocess.run(["git", *args], cwd=self.checkout, check=True, env=self.env)
|
||||
|
||||
def archive_chunk(self, at, outcome=outcomes.finished):
|
||||
def archive_chunk(self, at, outcome=outcomes.finished, worktree=None):
|
||||
"""Archives a chunk whose worker read a.py in worktree, else in the checkout."""
|
||||
transcript = self.home / ".claude" / "projects" / "-proj" / f"{folder_name()}.jsonl"
|
||||
(transcript.with_suffix("") / "subagents").mkdir(parents=True)
|
||||
worker = [said("1", "m1", tokens=10, cwd=str(self.checkout), name="Read", input={"file_path": str(self.checkout / "a.py")}), said("2", "m2", command="git commit -m x")]
|
||||
read_in = worktree or self.checkout
|
||||
worker = [said("1", "m1", tokens=10, cwd=str(read_in), name="Read", input={"file_path": str(read_in / "a.py")}), said("2", "m2", command="git commit -m x")]
|
||||
transcript.write_bytes(jsonl([{"timestamp": str(at)}, *worker]))
|
||||
(transcript.with_suffix("") / "subagents" / "agent-a.jsonl").write_bytes(jsonl([said("1", "s1", tokens=1)]))
|
||||
with contextlib.redirect_stderr(io.StringIO()):
|
||||
@@ -189,6 +192,14 @@ class ReadingCostTool(unittest.TestCase):
|
||||
self.assertEqual(reset.stdout, f"Appended 0 reading-cost figures from {self.home / '.claude' / 'loop-claude-transcripts' / 'proj'} and a reset to {history}.\n0 chunks measured since the last reset; the trend needs 10.\n")
|
||||
self.assertRegex(history.read_text(), r"\n## Reading cost reset, \d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ\n$")
|
||||
|
||||
def test_counts_a_file_read_in_a_worktree_the_configs_branch_template_names(self):
|
||||
config = self.home / ".claude-projects" / "proj" / "config.toml"
|
||||
config.write_text(config.read_text() + 'branch = "feature/PAY-{id}"\n')
|
||||
self.archive_chunk(1790000100, worktree=self.home / "code" / "proj-feature-PAY-7")
|
||||
ran = self.run_tool(self.checkout)
|
||||
self.assertEqual(ran.returncode, 0, ran.stderr)
|
||||
self.assertIn("- `a.py` 1\n", (self.checkout / "docs" / "reading-cost.md").read_text())
|
||||
|
||||
def test_refuses_an_option_it_does_not_know(self):
|
||||
ran = self.run_tool(self.checkout, "--rest")
|
||||
self.assertEqual((ran.returncode, ran.stdout), (1, ""))
|
||||
@@ -210,8 +221,8 @@ class Located(unittest.TestCase):
|
||||
for args in (("init", "--quiet"), ("add", ".")):
|
||||
subprocess.run(["git", *args], check=True, cwd=root, env=isolated_env())
|
||||
with contextlib.chdir(root / "sub"):
|
||||
found = main.located()
|
||||
self.assertEqual(found, Checkout(str(root), str(root), frozenset({"a.txt", "sub/b.txt"})))
|
||||
found = main.located(BRANCH)
|
||||
self.assertEqual(found, Checkout(str(root), str(root), frozenset({"a.txt", "sub/b.txt"}), BRANCH))
|
||||
|
||||
def test_fails_in_a_checkout_whose_path_holds_a_newline(self):
|
||||
temp = tempfile.TemporaryDirectory()
|
||||
@@ -220,7 +231,7 @@ class Located(unittest.TestCase):
|
||||
root.mkdir()
|
||||
subprocess.run(["git", "init", "--quiet"], check=True, cwd=root, env=isolated_env())
|
||||
with contextlib.chdir(root):
|
||||
self.assertIsInstance(main.located(), Failure)
|
||||
self.assertIsInstance(main.located(BRANCH), Failure)
|
||||
|
||||
|
||||
class Update(unittest.TestCase):
|
||||
@@ -230,7 +241,7 @@ class Update(unittest.TestCase):
|
||||
return Failure("the wiki is down")
|
||||
|
||||
archive = pathlib.Path(self.enterContext(tempfile.TemporaryDirectory()))
|
||||
updated = main.update(Unwritable("# Reading cost\n"), archive, Checkout("/c/p", "/c/p", frozenset()), "/h", "2026-11-14T00:00:00Z")
|
||||
updated = main.update(Unwritable("# Reading cost\n"), archive, Checkout("/c/p", "/c/p", frozenset(), BRANCH), "/h", "2026-11-14T00:00:00Z")
|
||||
self.assertEqual(updated, Failure("the wiki is down"))
|
||||
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@ from git_cli.git_repo import commits_since, file_at, git, Git
|
||||
from release_plan.release import dated, dated_heading_pattern, newest_tag, parsed, Release, tagged
|
||||
from failure import Failure
|
||||
from release_plan.todo_table import Item, items, next_item, renames
|
||||
from project_config.settings import Place
|
||||
from project_config.settings import Place, ProjectConfig
|
||||
from text_files.markdown_text import sections
|
||||
from record_store import stores
|
||||
from project_config import templates
|
||||
@@ -96,14 +96,19 @@ class DefaultPlan:
|
||||
cut: LastCut
|
||||
|
||||
|
||||
def default_plan(root: str, ref: str, plan: Place, changelog: stores.RecordStore, run: Git = git, *, title: str = templates.TITLE) -> DefaultPlan:
|
||||
"""What ref, the default branch as last fetched, holds for the pick, read in the checkout at root through run. plan is where the project's config puts todo.md, changelog the store it names for the changelog, and title its `commit-title` template."""
|
||||
def project_plan(config: ProjectConfig, ref: str, root: str, run: Git = git) -> DefaultPlan:
|
||||
"""default_plan for the project config describes: its plan, its changelog and its title templates."""
|
||||
return default_plan(root, ref, config.place("plan"), stores.store(config, "changelog"), config.titles, run)
|
||||
|
||||
|
||||
def default_plan(root: str, ref: str, plan: Place, changelog: stores.RecordStore, titles: templates.Titles, run: Git = git) -> DefaultPlan:
|
||||
"""What ref, the default branch as last fetched, holds for the pick, read in the checkout at root through run. plan is where the project's config puts todo.md, changelog the store it names for the changelog, and titles its title templates."""
|
||||
tag = newest_tag(root, merged_into=ref, run=run)
|
||||
changes = stores.held_at(ref, changelog, root, run)
|
||||
after = dated_cut(tag, changes)
|
||||
since = tag if after is None else heading_commit(after, ref, changelog, root, run)
|
||||
commits = since if isinstance(since, Failure) else commits_since(since, ref, root, run)
|
||||
reviewed = tag if isinstance(tag, Failure) else release_reviewed(tag, ref, root, after, run, title)
|
||||
reviewed = tag if isinstance(tag, Failure) else release_reviewed(tag, ref, root, titles, after, run)
|
||||
return DefaultPlan(held_at(ref, plan, root, run), LastCut(tag, changes, commits, todos_since(tag, ref, plan, root, run), reviewed))
|
||||
|
||||
|
||||
@@ -128,15 +133,15 @@ def heading_commit(release: Release, ref: str, changelog: stores.RecordStore, cw
|
||||
return added if isinstance(added, Failure) else next(iter(added.split()), None)
|
||||
|
||||
|
||||
def release_reviewed(tag: str | None, ref: str, cwd: str, after: Release | None = None, run: Git = git, title: str = templates.TITLE) -> bool | Failure:
|
||||
def release_reviewed(tag: str | None, ref: str, cwd: str, titles: templates.Titles, after: Release | None = None, run: Git = git) -> bool | Failure:
|
||||
"""Whether ref holds a commit titled as a release review opens, `Release review of <release>`: after tag, or anywhere where tag is None.
|
||||
|
||||
Each title is read as its summary in title, the project's `commit-title` template. after is the version a branch with no tag counts as cut, or None. Where it is given, a title counts only where its release is later than after.
|
||||
titles holds the project's title templates, and each commit title is read as the summary they give. after is the version a branch with no tag counts as cut, or None. Where it is given, a title counts only where its release is later than after.
|
||||
"""
|
||||
titles = run("log", "--format=%s", f"{tag}..{ref}" if tag else ref, cwd=cwd)
|
||||
if isinstance(titles, Failure):
|
||||
return titles
|
||||
summaries = [templates.summary_of(title, line) for line in titles.splitlines()]
|
||||
log = run("log", "--format=%s", f"{tag}..{ref}" if tag else ref, cwd=cwd)
|
||||
if isinstance(log, Failure):
|
||||
return log
|
||||
summaries = [titles.summary(line) for line in log.splitlines()]
|
||||
reviews = [summary.removeprefix("Release review of ") for summary in summaries if summary.startswith("Release review of ")]
|
||||
return any(after is None or ((named := parsed(review)) is not None and named > after) for review in reviews)
|
||||
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import dataclasses
|
||||
import pathlib
|
||||
import subprocess
|
||||
import sys
|
||||
@@ -6,9 +7,11 @@ import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from project_config.templates import BARE, Titles
|
||||
from failure import Failure
|
||||
from record_store.stores import FileStore
|
||||
from test_env import isolated_env
|
||||
from project_config.settings import ProjectConfig
|
||||
from release_plan import release_standing
|
||||
from release_plan import todo_table
|
||||
from release_plan.release import version
|
||||
@@ -157,18 +160,24 @@ class ChunkItem(unittest.TestCase):
|
||||
run("commit", "-q", "--allow-empty", "-m", "Release review of 0.1.0")
|
||||
run("tag", "v0.1.0")
|
||||
run("commit", "-q", "--allow-empty", "-m", "Ship item 4")
|
||||
self.assertIs(release_standing.release_reviewed("v0.1.0", "main", repo), False, "a review before the cut reviewed that release")
|
||||
self.assertIs(release_standing.release_reviewed("v0.1.0", "main", repo, BARE), False, "a review before the cut reviewed that release")
|
||||
run("commit", "-q", "--allow-empty", "-m", "Release review of 0.2.0")
|
||||
run("commit", "-q", "--allow-empty", "-m", "Answer architecture round 1: 0 🔴, 1 🟡 (0 misread); split loader")
|
||||
self.assertIs(release_standing.release_reviewed("v0.1.0", "main", repo), True)
|
||||
self.assertIs(release_standing.release_reviewed(None, "main", repo), True)
|
||||
self.assertIsInstance(release_standing.release_reviewed("v9.9.9", "main", repo), Failure)
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut.reviewed, True)
|
||||
self.assertIs(release_standing.release_reviewed("v0.1.0", "main", repo, BARE), True)
|
||||
self.assertIs(release_standing.release_reviewed(None, "main", repo, BARE), True)
|
||||
self.assertIsInstance(release_standing.release_reviewed("v9.9.9", "main", repo, BARE), Failure)
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE).cut.reviewed, True)
|
||||
run("tag", "v0.2.0")
|
||||
run("commit", "-q", "--allow-empty", "-m", "PAY-9 - Release review of 0.3.0")
|
||||
self.assertIs(release_standing.release_reviewed("v0.2.0", "main", repo), False)
|
||||
self.assertIs(release_standing.release_reviewed("v0.2.0", "main", repo, title="PAY-{id} - {summary}"), True)
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), title="PAY-{id} - {summary}").cut.reviewed, True)
|
||||
self.assertIs(release_standing.release_reviewed("v0.2.0", "main", repo, BARE), False)
|
||||
self.assertIs(release_standing.release_reviewed("v0.2.0", "main", repo, Titles("PAY-{id} - {summary}", "{summary}")), True)
|
||||
self.assertIs(release_standing.release_reviewed("v0.2.0", "main", repo, Titles("{summary}", "PAY-{id} - {summary}")), True, "a squash merge titles the commit as the pull request")
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), Titles("PAY-{id} - {summary}", "{summary}")).cut.reviewed, True)
|
||||
paths = {"plan": pathlib.Path(repo, "todo.md"), "changelog": pathlib.Path(repo, "CHANGELOG.md")}
|
||||
config = ProjectConfig("acme", pathlib.Path(repo, "folder"), pathlib.Path(repo), paths)
|
||||
self.assertIs(release_standing.project_plan(config, "main", repo).cut.reviewed, False)
|
||||
self.assertIs(release_standing.project_plan(dataclasses.replace(config, commit_title="PAY-{id} - {summary}"), "main", repo).cut.reviewed, True)
|
||||
self.assertIs(release_standing.project_plan(dataclasses.replace(config, pull_request_title="PAY-{id} - {summary}"), "main", repo).cut.reviewed, True)
|
||||
|
||||
def test_counts_no_release_review_of_a_release_cut_under_a_dated_heading_on_a_branch_with_no_tag(self):
|
||||
repo = tempfile.mkdtemp()
|
||||
@@ -179,13 +188,13 @@ class ChunkItem(unittest.TestCase):
|
||||
pathlib.Path(repo, "CHANGELOG.md").write_text("# Changelog\n\n## 0.0.1 - 2026-10-03\n")
|
||||
run("add", "CHANGELOG.md")
|
||||
run("commit", "-q", "-m", "Cut 0.0.1")
|
||||
self.assertIs(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut.reviewed, False, "that review reviewed 0.0.1, which is cut")
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut.commits, 0, "no commit follows the one that cut 0.0.1")
|
||||
self.assertEqual(release_standing.chunk_item([], release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut), release_standing.Unplanned(None))
|
||||
self.assertIs(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE).cut.reviewed, False, "that review reviewed 0.0.1, which is cut")
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE).cut.commits, 0, "no commit follows the one that cut 0.0.1")
|
||||
self.assertEqual(release_standing.chunk_item([], release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE).cut), release_standing.Unplanned(None))
|
||||
run("commit", "-q", "--allow-empty", "-m", "Ship item 2")
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut.commits, 1)
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE).cut.commits, 1)
|
||||
run("commit", "-q", "--allow-empty", "-m", "Release review of 0.1.0")
|
||||
self.assertIs(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut.reviewed, True)
|
||||
self.assertIs(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE).cut.reviewed, True)
|
||||
|
||||
def test_counts_from_the_commit_on_the_named_branch_that_first_added_the_dated_heading_to_changelog_md(self):
|
||||
repo = tempfile.mkdtemp()
|
||||
@@ -204,7 +213,7 @@ class ChunkItem(unittest.TestCase):
|
||||
run("commit", "-q", "--allow-empty", "-m", "Ship item 2")
|
||||
run("checkout", "-q", "-b", "side")
|
||||
run("commit", "-q", "--allow-empty", "-m", "Side work")
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut.commits, 2, "the commits after Cut 0.0.1 on main")
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE).cut.commits, 2, "the commits after Cut 0.0.1 on main")
|
||||
|
||||
def test_reads_the_changelog_and_its_cut_on_the_named_branch_whatever_is_checked_out(self):
|
||||
repo = tempfile.mkdtemp()
|
||||
@@ -224,7 +233,7 @@ class ChunkItem(unittest.TestCase):
|
||||
run("commit", "-q", "--allow-empty", "-m", "Ship item 2")
|
||||
run("checkout", "-q", "side")
|
||||
changelog.write_text("# Changelog\n\nAn edit nobody committed.\n")
|
||||
cut = release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut
|
||||
cut = release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE).cut
|
||||
self.assertEqual((cut.changelog, cut.commits), ("# Changelog\n\n## 0.0.1 - 2026-10-03\n", 1), "main's changelog, and the commit after Cut 0.0.1 on main")
|
||||
|
||||
def test_takes_the_tag_over_a_dated_heading_and_counts_every_commit_without_either(self):
|
||||
@@ -235,12 +244,12 @@ class ChunkItem(unittest.TestCase):
|
||||
pathlib.Path(repo, "todo.md").write_text(HEADER + ROW.format(id=1, release="0.2.0"))
|
||||
run("add", "todo.md")
|
||||
run("commit", "-q", "-m", "Plan")
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut, release_standing.LastCut(None, "", 1, [HEADER + ROW.format(id=1, release="0.2.0")], False))
|
||||
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE).cut, release_standing.LastCut(None, "", 1, [HEADER + ROW.format(id=1, release="0.2.0")], False))
|
||||
run("tag", "v0.1.0")
|
||||
pathlib.Path(repo, "CHANGELOG.md").write_text("# Changelog\n\n## 0.2.0 - 2026-10-03\n")
|
||||
run("add", "CHANGELOG.md")
|
||||
run("commit", "-q", "-m", "Date 0.2.0")
|
||||
held = release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo))
|
||||
held = release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo), BARE)
|
||||
self.assertEqual(held.todo, HEADER + ROW.format(id=1, release="0.2.0"))
|
||||
self.assertEqual(held.cut, release_standing.LastCut("v0.1.0", "# Changelog\n\n## 0.2.0 - 2026-10-03\n", 1, [HEADER + ROW.format(id=1, release="0.2.0")], False))
|
||||
self.assertEqual(release_standing.chunk_item(plan_under((0, 2, 0)), held.cut), release_standing.Next((0, 2, 0), one((0, 2, 0))))
|
||||
@@ -253,16 +262,16 @@ class ChunkItem(unittest.TestCase):
|
||||
pathlib.Path(repo, "todo.md").write_text(HEADER + ROW.format(id=1, release="0.9.0"))
|
||||
run("add", "todo.md")
|
||||
run("commit", "-q", "-m", "A todo.md the project's owners keep")
|
||||
held = release_standing.default_plan(repo, "main", folder / "todo.md", FileStore(folder / "CHANGELOG.md", None))
|
||||
held = release_standing.default_plan(repo, "main", folder / "todo.md", FileStore(folder / "CHANGELOG.md", None), BARE)
|
||||
self.assertEqual((held.todo, held.cut), ("", release_standing.LastCut(None, "", 1, [""], False)), "neither file exists yet")
|
||||
plan = HEADER + ROW.format(id=2, release="0.2.0")
|
||||
(folder / "todo.md").write_text(plan)
|
||||
(folder / "CHANGELOG.md").write_text("# Changelog\n\n## 0.1.0 - 2026-10-03\n")
|
||||
held = release_standing.default_plan(repo, "main", folder / "todo.md", FileStore(folder / "CHANGELOG.md", None))
|
||||
held = release_standing.default_plan(repo, "main", folder / "todo.md", FileStore(folder / "CHANGELOG.md", None), BARE)
|
||||
self.assertEqual(held.todo, plan)
|
||||
self.assertEqual(held.cut, release_standing.LastCut(None, "# Changelog\n\n## 0.1.0 - 2026-10-03\n", 1, [plan], False))
|
||||
(folder / "todo.md").write_bytes(b"\xff")
|
||||
unreadable = release_standing.default_plan(repo, "main", folder / "todo.md", changelog_of(repo))
|
||||
unreadable = release_standing.default_plan(repo, "main", folder / "todo.md", changelog_of(repo), BARE)
|
||||
assert isinstance(unreadable.todo, Failure) and isinstance(unreadable.cut.todos_since, Failure), unreadable
|
||||
self.assertTrue(unreadable.todo.reason.startswith(f"cannot read {folder}/todo.md: "), unreadable.todo.reason)
|
||||
self.assertEqual(unreadable.cut.todos_since, unreadable.todo)
|
||||
@@ -279,7 +288,7 @@ class ChunkItem(unittest.TestCase):
|
||||
run("commit", "-q", "-m", "Cut 0.1.0")
|
||||
# Only this git knows where the checkout is, so a read that goes round it fails.
|
||||
there = lambda *args, cwd: release_standing.git(*args, cwd=repo)
|
||||
held = release_standing.default_plan("/nowhere", "main", "todo.md", changelog_of("/nowhere"), there)
|
||||
held = release_standing.default_plan("/nowhere", "main", "todo.md", changelog_of("/nowhere"), BARE, there)
|
||||
self.assertEqual(held, release_standing.DefaultPlan(plan, release_standing.LastCut(None, "# Changelog\n\n## 0.1.0 - 2026-10-03\n", 0, [plan], False)))
|
||||
|
||||
def test_counts_the_changes_unreleased_since_the_last_cut_by_unreleased_entries_and_else_by_commits(self):
|
||||
|
||||
@@ -12,11 +12,12 @@ from branch_chunks.read import branch_chunks, unsupported
|
||||
from branch_chunks.cut import BranchChunk
|
||||
from transcript_archive.project_key import checkout_of
|
||||
from routing_figures.chunk import Chunk, chunk_figures, ChunkFigures, Subagent
|
||||
from project_config.main import commit_title
|
||||
from git_cli.git_repo import default_ref, Git
|
||||
from claude_code.entries import Entry, parse_entry
|
||||
from failure import Failure
|
||||
from text_files.file_writes import replace_file
|
||||
from project_config.main import title_templates
|
||||
from project_config.templates import Titles
|
||||
from transcript_archive.outcomes import VERDICT_AT
|
||||
|
||||
FIGURES = "routing-figures.md"
|
||||
@@ -55,7 +56,7 @@ def cycles(root: pathlib.Path) -> int | Failure:
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class ArchiveChunks:
|
||||
"""skipped names each chunk folder that could not be read whole, such as one another loop is writing; unread names each project whose default branch could not be read, with why."""
|
||||
"""skipped names each chunk folder that could not be read whole, such as one another loop is writing; unread names each project whose default branch or config could not be read, with why."""
|
||||
chunks: list[ChunkFigures]
|
||||
skipped: tuple[str, ...]
|
||||
unread: tuple[str, ...] = ()
|
||||
@@ -83,7 +84,12 @@ def measure_project(root: pathlib.Path, project: pathlib.Path, home: str, since:
|
||||
chunks = [chunk for chunk in listed if chunk.finished > since]
|
||||
if not chunks:
|
||||
return ArchiveChunks([], ())
|
||||
history = branch_history(checkout_of(key, pathlib.Path(home)), pathlib.Path(home), git)
|
||||
checkout = checkout_of(key, pathlib.Path(home))
|
||||
titles = title_templates(checkout, pathlib.Path(home), functools.partial(git, timeout=GIT_TIMEOUT, guarded=True))
|
||||
if isinstance(titles, Failure):
|
||||
# Read bare, a templated project's round titles would count as no round.
|
||||
return ArchiveChunks([], (), (f"{key}: none of its chunks is measured: {titles.reason}",))
|
||||
history = branch_history(checkout, pathlib.Path(home), titles, git)
|
||||
found = []
|
||||
skipped = []
|
||||
for chunk in chunks:
|
||||
@@ -95,17 +101,17 @@ def measure_project(root: pathlib.Path, project: pathlib.Path, home: str, since:
|
||||
except (OSError, UnicodeDecodeError):
|
||||
skipped.append(str(folder.relative_to(root)))
|
||||
continue
|
||||
found.append(chunk_figures(Chunk(key, kept, worker, subagents), home, None if isinstance(history, Failure) else history))
|
||||
found.append(chunk_figures(Chunk(key, kept, worker, subagents), home, titles, None if isinstance(history, Failure) else history))
|
||||
return ArchiveChunks(found, tuple(skipped), (f"{key}: {history.reason}",) if isinstance(history, Failure) else ())
|
||||
|
||||
|
||||
def branch_history(checkout: str, home: pathlib.Path, git: Git) -> list[BranchChunk] | Failure:
|
||||
"""The chunks on the checkout's default branch as last fetched, read guarded, since the checkout's config may name a program. A Failure where the project's config under home puts the plan or a record where branch_chunks reads no commits."""
|
||||
def branch_history(checkout: str, home: pathlib.Path, titles: Titles, git: Git) -> list[BranchChunk] | Failure:
|
||||
"""The chunks on the checkout's default branch as last fetched, each title read through titles, the project's title templates; read guarded, since the checkout's config may name a program. A Failure where the project's config under home puts the plan or a record where branch_chunks reads no commits."""
|
||||
guarded = functools.partial(git, cwd=checkout, timeout=GIT_TIMEOUT, guarded=True)
|
||||
if why := unsupported(checkout, home, guarded):
|
||||
return Failure(f"its chunks' items and later fixes are not counted: {why}")
|
||||
ref = default_ref(checkout, GIT_TIMEOUT, guarded=True, run=git)
|
||||
return ref if isinstance(ref, Failure) else branch_chunks(ref, guarded, commit_title(checkout, home, guarded))
|
||||
return ref if isinstance(ref, Failure) else branch_chunks(ref, guarded, titles)
|
||||
|
||||
|
||||
def entries(path: pathlib.Path) -> list[Entry]:
|
||||
|
||||
@@ -12,6 +12,7 @@ from transcript_archive.outcomes import judge_costs, UNFINISHED_AT, workers
|
||||
from review_rules.round_titles import rounds_past_first
|
||||
from model_routing.ladder import Rung
|
||||
from command_lines.shell_command import simple_commands
|
||||
from project_config.templates import Titles
|
||||
|
||||
ESCALATION = re.compile(rf"{ESCALATION_MARKER} ([0-9]+):")
|
||||
|
||||
@@ -59,8 +60,8 @@ class ChunkFigures:
|
||||
fixed_later: int | None = None
|
||||
|
||||
|
||||
def chunk_figures(chunk: Chunk, home: str, history: list[BranchChunk] | None = None) -> ChunkFigures:
|
||||
"""history is the chunks on the project's default branch, None where it could not be read."""
|
||||
def chunk_figures(chunk: Chunk, home: str, titles: Titles, history: list[BranchChunk] | None = None) -> ChunkFigures:
|
||||
"""titles holds the project's title templates, which each commit title is read through. history is the chunks on the project's default branch, None where it could not be read."""
|
||||
cycles = sorted((cycle for kept in chunk.outcomes for cycle in workers(kept)), key=lambda cycle: cycle[0])
|
||||
launches = agent_calls(chunk.worker)
|
||||
reported = results(chunk.worker)
|
||||
@@ -70,7 +71,7 @@ def chunk_figures(chunk: Chunk, home: str, history: list[BranchChunk] | None = N
|
||||
return ChunkFigures(
|
||||
dollars=dollars,
|
||||
start=start.rung if start and start.item else None,
|
||||
rounds_past_first=rounds_past_first(commit_titles(chunk.worker, home)),
|
||||
rounds_past_first=rounds_past_first([titles.summary(title) for title in commit_titles(chunk.worker, home)]),
|
||||
unfinished=sum(len(UNFINISHED_AT.findall(kept)) for kept in chunk.outcomes),
|
||||
delegated=collections.Counter(one.rung for one in delegated),
|
||||
reports=reports_by_type(delegated),
|
||||
|
||||
@@ -15,10 +15,11 @@ import unittest.mock
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from routing_figures import archive, state
|
||||
from project_config.templates import BARE, Titles
|
||||
from branch_chunks.cut import BranchChunk
|
||||
from routing_figures.calls import Call, calls, totals
|
||||
from routing_figures.chunk import Chunk, chunk_figures, ChunkFigures, Reports, Subagent
|
||||
from project_config.test_project_config import configured
|
||||
from project_config.test_project_config import configured, write_config
|
||||
from routing_figures.state import due
|
||||
from claude_code.entries import entry_from
|
||||
from failure import Failure
|
||||
@@ -90,7 +91,7 @@ class Measured(unittest.TestCase):
|
||||
message("m3", "2026-10-14T11:00:00.000Z", {"type": "text", "text": "on"}),
|
||||
]
|
||||
kept = stamped("2026-10-14T10:30:00Z", outcomes.unfinished(LOW_ROUTE, "e", "j", "")) + stamped("2026-10-14T10:30:00Z", outcomes.stepped_up(Route(HIGH).worker_line())) + stamped("2026-10-14T12:00:00Z", outcomes.finished(Route(HIGH).worker_line(), "merged", "j"))
|
||||
found = chunk_figures(chunk_of("log", [kept], worker, []), "/h")
|
||||
found = chunk_figures(chunk_of("log", [kept], worker, []), "/h", BARE)
|
||||
self.assertEqual(found.dollars["project"], {"log": 6.0})
|
||||
self.assertEqual(found.dollars["subagent type"], {"worker": 6.0})
|
||||
self.assertEqual(found.dollars["rung"], {str(LOW): 4.0, str(HIGH): 2.0})
|
||||
@@ -99,7 +100,7 @@ class Measured(unittest.TestCase):
|
||||
|
||||
def test_counts_the_judges_recorded_cost_under_the_judge_and_the_rung_it_ran_on(self):
|
||||
kept = stamped("2026-10-14T10:30:00Z", outcomes.unfinished(LOW_ROUTE, "e", "judge-rung", "", judge_cost=0.5)) + stamped("2026-10-14T12:00:00Z", outcomes.finished(LOW_ROUTE, "m", "judge-rung", judge_cost=0.25)) + stamped("2026-10-14T12:00:00Z", outcomes.rejected("why", "{}", "other-rung", judge_cost=1.0))
|
||||
found = chunk_figures(chunk_of("log", [kept], [message("m1", "2026-10-14T10:00:00Z")], []), "/h")
|
||||
found = chunk_figures(chunk_of("log", [kept], [message("m1", "2026-10-14T10:00:00Z")], []), "/h", BARE)
|
||||
self.assertEqual(found.dollars["project"], {"log": 3.75})
|
||||
self.assertEqual(found.dollars["subagent type"], {"worker": 2.0, "judge": 1.75})
|
||||
self.assertEqual(found.dollars["rung"], {str(LOW): 2.0, "judge-rung": 0.75, "other-rung": 1.0})
|
||||
@@ -115,7 +116,7 @@ class Measured(unittest.TestCase):
|
||||
subagent_of("Explore", "a1", [message("s1", "2026-10-14T10:00:01Z", model="claude-sonnet-5-5"), result("r", "z" * 20)]),
|
||||
subagent_of("", "a2", [message("s2", "2026-10-14T10:00:01Z")]),
|
||||
]
|
||||
found = chunk_figures(chunk_of("log", [stamped("2026-10-14T11:00:00Z", outcomes.finished(LOW_ROUTE, "m", "j"))], worker, subagents), "/h")
|
||||
found = chunk_figures(chunk_of("log", [stamped("2026-10-14T11:00:00Z", outcomes.finished(LOW_ROUTE, "m", "j"))], worker, subagents), "/h", BARE)
|
||||
self.assertEqual(found.delegated, {"claude-sonnet-5-5 at high effort": 1, str(LOW): 1})
|
||||
self.assertEqual(found.dollars["subagent type"], {"worker": 2.0, "Explore": 3.0})
|
||||
self.assertEqual(found.reports, {"Explore": Reports(2, 35, 20)})
|
||||
@@ -125,16 +126,22 @@ class Measured(unittest.TestCase):
|
||||
message("m1", "2026-10-14T10:00:00Z", call("Agent", "a1", prompt="Escalation trigger 2: the test failed twice"), call("Agent", "a2", prompt="Escalation trigger 2: again"), call("Agent", "a3", prompt="Escalation trigger 3: a 🔴 in round 2")),
|
||||
message("m2", "2026-10-14T10:01:00Z", call("Agent", "a4", prompt="Find the callers. Escalation trigger 1: not at the start"), call("Agent", "a5", prompt="Escalation trigger x: no number")),
|
||||
]
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, []), "/h").escalated, {2: 2, 3: 1})
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, []), "/h", BARE).escalated, {2: 2, 3: 1})
|
||||
|
||||
def test_counts_review_rounds_past_each_passs_first_once_per_title(self):
|
||||
commit = lambda id_, title: message(id_, "2026-10-14T10:00:00Z", call("Bash", command=f"git commit -m '{title}'"))
|
||||
worker = [commit("m1", "Answer stability round 1: 1 🔴, 0 🟡"), commit("m2", "Answer stability round 2: 0 🔴, 0 🟡"), commit("m3", "Answer stability round 2: 0 🔴, 0 🟡"), commit("m4", "Answer prose round 1: 0 🔴, 1 🟡")]
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, []), "/h").rounds_past_first, 1)
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, []), "/h", BARE).rounds_past_first, 1)
|
||||
|
||||
def test_reads_each_round_title_through_the_projects_title_templates(self):
|
||||
commit = lambda id_, title: message(id_, "2026-10-14T10:00:00Z", call("Bash", command=f"git commit -m '{title}'"))
|
||||
worker = [commit("m1", "PAY-7 - Answer stability round 1: 1 🔴, 0 🟡"), commit("m2", "PAY-7 - Answer stability round 2: 0 🔴, 0 🟡")]
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, []), "/h", Titles("PAY-{id} - {summary}", "{summary}")).rounds_past_first, 1)
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, []), "/h", BARE).rounds_past_first, 0)
|
||||
|
||||
def fixed_later(self, history, route=LOW_ROUTE):
|
||||
"""The later fixes measured counts for a chunk that route started, which LOW_ROUTE does by item 7, on a project whose default branch holds history, None where it could not be read."""
|
||||
return chunk_figures(chunk_of("log", [stamped("2026-10-14T10:00:00Z", outcomes.finished(route, "m", "j"))], [], []), "/h", history).fixed_later
|
||||
return chunk_figures(chunk_of("log", [stamped("2026-10-14T10:00:00Z", outcomes.finished(route, "m", "j"))], [], []), "/h", BARE, history).fixed_later
|
||||
|
||||
def test_counts_the_later_fixes_of_the_chunk_that_shipped_the_item_its_route_names(self):
|
||||
self.assertEqual(self.fixed_later([shipping(6, fixed_by=("c", "d", "e")), shipping(5, 7, fixed_by=("c", "d"))]), 2)
|
||||
@@ -154,7 +161,7 @@ class Measured(unittest.TestCase):
|
||||
|
||||
def test_starts_no_route_for_a_chunk_no_item_routed(self):
|
||||
kept = stamped("2026-10-14T10:00:00Z", outcomes.finished(Route(LOW).worker_line(), "m", "j"))
|
||||
found = chunk_figures(chunk_of("log", [kept], [message("m1", "2026-10-14T09:00:00Z")], []), "/h")
|
||||
found = chunk_figures(chunk_of("log", [kept], [message("m1", "2026-10-14T09:00:00Z")], []), "/h", BARE)
|
||||
self.assertIsNone(found.start)
|
||||
self.assertEqual(found.dollars["rung"], {str(LOW): 2.0})
|
||||
|
||||
@@ -166,14 +173,14 @@ class Measured(unittest.TestCase):
|
||||
message("m3", "2026-10-14T10:31:00Z", call("Agent", "a2", subagent_type="Explore")),
|
||||
]
|
||||
subagents = [subagent_of("Explore", "a1", [result("r", "x")]), subagent_of("Explore", "a2", [message("s2", "2026-10-14T10:31:01Z", model="claude-fable-5-2")])]
|
||||
found = chunk_figures(chunk_of("log", [kept], worker, subagents), "/h")
|
||||
found = chunk_figures(chunk_of("log", [kept], worker, subagents), "/h", BARE)
|
||||
self.assertEqual(found.delegated, {"sonnet at low effort": 1, str(HIGH): 1})
|
||||
self.assertEqual(found.dollars["rung"], {str(LOW): 2.0, str(HIGH): 8.0})
|
||||
|
||||
def test_names_a_subagent_by_its_meta_or_else_its_call_or_else_unknown(self):
|
||||
worker = [message("m1", "2026-10-14T10:00:00Z", call("Agent", "a1", subagent_type="Explore"), call("Agent", "a2", subagent_type="Plan"))]
|
||||
subagents = [subagent_of("stability-reviewer", "a1", []), subagent_of("", "a2", []), subagent_of("", "", [])]
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, subagents), "/h").reports, {"stability-reviewer": Reports(1, 0, 0), "Plan": Reports(1, 0, 0), "unknown": Reports(1, 0, 0)})
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, subagents), "/h", BARE).reports, {"stability-reviewer": Reports(1, 0, 0), "Plan": Reports(1, 0, 0), "unknown": Reports(1, 0, 0)})
|
||||
|
||||
def test_counts_a_message_without_usage_or_a_priced_model_as_nothing_and_splits_a_cost_evenly_across_tools(self):
|
||||
worker = [
|
||||
@@ -183,20 +190,20 @@ class Measured(unittest.TestCase):
|
||||
{"type": "assistant", "uuid": "u3", "message": {"model": "claude-opus-5-5", "content": []}},
|
||||
{"type": "assistant", "uuid": "u4", "message": {"model": "claude-unheard-of", "content": [], "usage": {"input_tokens": 9_000_000}}},
|
||||
]
|
||||
found = chunk_figures(chunk_of("log", [], worker, []), "/h")
|
||||
found = chunk_figures(chunk_of("log", [], worker, []), "/h", BARE)
|
||||
self.assertEqual(found.dollars["tool"], {"prompt": 4.0, "Read": 4.0, "Grep": 4.0})
|
||||
self.assertEqual(found.dollars["project"], {"log": 12.0})
|
||||
|
||||
def test_prices_input_cache_writes_by_their_lifetime_cache_reads_and_output_at_the_models_list_prices(self):
|
||||
usage = {"input_tokens": 1_000_000, "cache_creation_input_tokens": 2_000_000, "cache_creation": {"ephemeral_5m_input_tokens": 1_000_000, "ephemeral_1h_input_tokens": 1_000_000}, "cache_read_input_tokens": 1_000_000, "output_tokens": 1_000_000}
|
||||
opus = chunk_figures(chunk_of("log", [], [message("m1", "2026-10-14T10:00:00Z", usage=usage)], []), "/h")
|
||||
opus = chunk_figures(chunk_of("log", [], [message("m1", "2026-10-14T10:00:00Z", usage=usage)], []), "/h", BARE)
|
||||
self.assertAlmostEqual(opus.dollars["project"]["log"], 4 + 5 + 8 + 0.2 + 20)
|
||||
sonnet = chunk_figures(chunk_of("log", [], [message("m1", "2026-10-14T10:00:00Z", model="claude-sonnet-5-5", usage=usage)], []), "/h")
|
||||
sonnet = chunk_figures(chunk_of("log", [], [message("m1", "2026-10-14T10:00:00Z", model="claude-sonnet-5-5", usage=usage)], []), "/h", BARE)
|
||||
self.assertAlmostEqual(sonnet.dollars["project"]["log"], 2 + 2.5 + 4 + 0.2 + 10)
|
||||
|
||||
def test_counts_a_cache_write_without_a_lifetime_as_a_five_minute_one(self):
|
||||
usage = {"cache_creation_input_tokens": 1_000_000}
|
||||
found = chunk_figures(chunk_of("log", [], [message("m1", "2026-10-14T10:00:00Z", usage=usage)], []), "/h")
|
||||
found = chunk_figures(chunk_of("log", [], [message("m1", "2026-10-14T10:00:00Z", usage=usage)], []), "/h", BARE)
|
||||
self.assertAlmostEqual(found.dollars["project"]["log"], 5)
|
||||
|
||||
def test_splits_the_cost_a_chunks_last_cost_state_records_for_each_model_across_its_messages_by_list_price(self):
|
||||
@@ -207,31 +214,31 @@ class Measured(unittest.TestCase):
|
||||
cost_state(claude_opus_5_5=9.0, claude_haiku_5_5=0.5),
|
||||
]
|
||||
subagents = [subagent_of("Explore", "a1", [message("s1", "2026-10-14T10:00:01Z")])]
|
||||
found = chunk_figures(chunk_of("log", [], worker, subagents), "/h")
|
||||
found = chunk_figures(chunk_of("log", [], worker, subagents), "/h", BARE)
|
||||
self.assertEqual(found.dollars["subagent type"], {"worker": 6.0, "Explore": 3.0})
|
||||
self.assertEqual(found.dollars["project"], {"log": 9.0})
|
||||
self.assertEqual(found.unattributed, 0.5)
|
||||
|
||||
def test_counts_the_subagents_the_worker_launched_that_have_no_transcript(self):
|
||||
worker = [message("m1", "2026-10-14T10:00:00Z", call("Agent", "a1", subagent_type="Explore"), call("Agent", "a2", subagent_type="Explore"), call("Read", "r1", file_path="/c/a"))]
|
||||
found = chunk_figures(chunk_of("log", [], worker, [subagent_of("Explore", "a1", [message("s1", "2026-10-14T10:00:01Z")])]), "/h")
|
||||
found = chunk_figures(chunk_of("log", [], worker, [subagent_of("Explore", "a1", [message("s1", "2026-10-14T10:00:01Z")])]), "/h", BARE)
|
||||
self.assertEqual(found.lacking, 1)
|
||||
unnamed = chunk_figures(chunk_of("log", [], worker, [subagent_of("", "", [message("s1", "2026-10-14T10:00:01Z")]), subagent_of("", "", [message("s2", "2026-10-14T10:00:02Z")])]), "/h")
|
||||
unnamed = chunk_figures(chunk_of("log", [], worker, [subagent_of("", "", [message("s1", "2026-10-14T10:00:01Z")]), subagent_of("", "", [message("s2", "2026-10-14T10:00:02Z")])]), "/h", BARE)
|
||||
self.assertEqual(unnamed.lacking, 0)
|
||||
nested = [message("s1", "2026-10-14T10:00:01Z", call("Agent", "n1", subagent_type="Explore"))]
|
||||
launched = chunk_figures(chunk_of("log", [], worker, [subagent_of("Explore", "a1", nested), subagent_of("Explore", "a2", [message("s2", "2026-10-14T10:00:02Z")]), subagent_of("Explore", "n1", [message("s3", "2026-10-14T10:00:03Z")])]), "/h")
|
||||
launched = chunk_figures(chunk_of("log", [], worker, [subagent_of("Explore", "a1", nested), subagent_of("Explore", "a2", [message("s2", "2026-10-14T10:00:02Z")]), subagent_of("Explore", "n1", [message("s3", "2026-10-14T10:00:03Z")])]), "/h", BARE)
|
||||
self.assertEqual(launched.lacking, 0)
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, [subagent_of("Explore", "a1", nested), subagent_of("Explore", "a2", [])]), "/h").lacking, 1)
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [], worker, [subagent_of("Explore", "a1", nested), subagent_of("Explore", "a2", [])]), "/h", BARE).lacking, 1)
|
||||
|
||||
def test_charges_a_message_without_a_timestamp_to_the_rung_of_the_last_outcome(self):
|
||||
undated = message("m1", "")
|
||||
del undated["timestamp"]
|
||||
kept = stamped("2026-10-14T10:30:00Z", outcomes.unfinished(LOW_ROUTE, "e", "j", "")) + stamped("2026-10-14T12:00:00Z", outcomes.finished(Route(HIGH).worker_line(), "merged", "j"))
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [kept], [undated], []), "/h").dollars["rung"], {str(HIGH): 2.0})
|
||||
self.assertEqual(chunk_figures(chunk_of("log", [kept], [undated], []), "/h", BARE).dollars["rung"], {str(HIGH): 2.0})
|
||||
|
||||
def test_keeps_list_prices_for_a_model_the_cost_state_does_not_name(self):
|
||||
worker = [message("m1", "2026-10-14T10:00:00Z"), message("m2", "2026-10-14T10:01:00Z", model="claude-sonnet-5-5"), cost_state(claude_opus_5_5=3.0)]
|
||||
found = chunk_figures(chunk_of("log", [], worker, []), "/h")
|
||||
found = chunk_figures(chunk_of("log", [], worker, []), "/h", BARE)
|
||||
self.assertEqual(found.dollars["project"], {"log": 4.0})
|
||||
self.assertEqual(found.unattributed, 0.0)
|
||||
|
||||
@@ -309,7 +316,7 @@ class BranchHistory(unittest.TestCase):
|
||||
folder = configured(self, checkout)
|
||||
config = folder / "config.toml"
|
||||
config.write_text(config.read_text().replace('"checkout:todo.md"', '"folder:todo.md"'))
|
||||
found = archive.branch_history(str(checkout), folder.parents[1], git_repo.git)
|
||||
found = archive.branch_history(str(checkout), folder.parents[1], BARE, git_repo.git)
|
||||
assert isinstance(found, Failure), found
|
||||
self.assertEqual(found.reason, f"its chunks' items and later fixes are not counted: the project's config puts {folder}/todo.md elsewhere than todo.md, docs/comprehension-history.md, docs/reading-cost.md in the checkout, the only paths whose commits are read so far")
|
||||
|
||||
@@ -352,6 +359,34 @@ class Archive(unittest.TestCase):
|
||||
found = archive.measure_archive(self.root, str(home), "", git_repo.git)
|
||||
self.assertEqual([(chunk.dollars["project"].keys(), chunk.fixed_later) for chunk in found.chunks], [({"log": 0}.keys(), 1)])
|
||||
|
||||
def test_reads_a_projects_round_titles_and_its_branchs_history_through_its_configs_templates(self):
|
||||
home = self.root / "home"
|
||||
env = {**isolated_env(), "GIT_CONFIG_GLOBAL": os.devnull, "HOME": str(home)}
|
||||
round_title = "PAY-8 - Answer stability round {}: 1 🔴, 0 🟡 (1 misread); fix"
|
||||
self.ship_then_fix(home / "code" / "log", env, round_title.format(1), ships_fix=False)
|
||||
config = write_config(home, home / "code" / "log") / "config.toml"
|
||||
worker = [message(f"m{n}", "2026-10-14T09:00:00Z", call("Bash", command=f"git commit -m '{round_title.format(n)}'")) for n in (1, 2)]
|
||||
self.chunk("log", "c1", stamped("2026-10-14T10:00:00Z", outcomes.finished(LOW_ROUTE, "m", "j")), worker)
|
||||
with unittest.mock.patch.dict(os.environ, env, clear=True):
|
||||
bare = archive.measure_archive(self.root, str(home), "", git_repo.git)
|
||||
config.write_text(config.read_text() + 'commit-title = "PAY-{id} - {summary}"\n')
|
||||
templated = archive.measure_archive(self.root, str(home), "", git_repo.git)
|
||||
self.assertEqual([(chunk.rounds_past_first, chunk.fixed_later) for chunk in bare.chunks], [(0, 0)])
|
||||
self.assertEqual([(chunk.rounds_past_first, chunk.fixed_later) for chunk in templated.chunks], [(1, 1)])
|
||||
|
||||
def test_measures_no_chunk_of_a_project_while_a_config_cannot_be_read_and_names_it(self):
|
||||
home = self.root / "home"
|
||||
env = {**isolated_env(), "GIT_CONFIG_GLOBAL": os.devnull, "HOME": str(home)}
|
||||
self.ship_then_fix(home / "code" / "log", env)
|
||||
config = write_config(home, home / "code" / "log") / "config.toml"
|
||||
config.write_text(config.read_text() + 'commit-title = "PAY-{id}"\n')
|
||||
self.chunk("log", "c1", stamped("2026-10-14T10:00:00Z", outcomes.finished(LOW_ROUTE, "m", "j")), [message("m1", "2026-10-14T09:00:00Z")])
|
||||
with unittest.mock.patch.dict(os.environ, env, clear=True):
|
||||
found = archive.measure_archive(self.root, str(home), "", git_repo.git)
|
||||
self.assertEqual(found.chunks, [])
|
||||
self.assertEqual(len(found.unread), 1)
|
||||
self.assertRegex(found.unread[0], r"^log: none of its chunks is measured: .*`commit-title` is 'PAY-\{id\}'")
|
||||
|
||||
def test_reads_each_projects_history_guarded_and_each_read_of_its_branch_time_limited(self):
|
||||
home = self.root / "home"
|
||||
env = {**isolated_env(), "GIT_CONFIG_GLOBAL": os.devnull, "HOME": str(home)}
|
||||
@@ -384,8 +419,8 @@ class Archive(unittest.TestCase):
|
||||
found = archive.measure_archive(self.root, "/h", "", no_checkout)
|
||||
self.assertEqual(([chunk.fixed_later for chunk in found.chunks], found.unread), ([None], ("gone: no checkout",)))
|
||||
|
||||
def ship_then_fix(self, checkout, env):
|
||||
"""Makes a checkout whose main branch merges the chunk that ships item 7 of LOW_ROUTE, then one that ships a defect item and rewrites a line item 7 shipped."""
|
||||
def ship_then_fix(self, checkout, env, fix_title="Fix six", ships_fix=True):
|
||||
"""Makes a checkout whose main branch merges the chunk that ships item 7 of LOW_ROUTE, then one titled fix_title that rewrites a line item 7 shipped, and ships a defect item where ships_fix."""
|
||||
checkout.mkdir(parents=True)
|
||||
git = lambda *args: subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], cwd=checkout, check=True, env=env, capture_output=True)
|
||||
plan = lambda rows: "# todo\n\n## Items\n\n| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves | Score |\n|---|---|---|---|---|---|---|---|---|---|---|---|\n" + rows
|
||||
@@ -405,7 +440,7 @@ class Archive(unittest.TestCase):
|
||||
git("add", "todo.md", "a.py")
|
||||
git("commit", "-q", "-m", "Start")
|
||||
merge("ship", "Ship seven", {"a.py": "1\nx\n", "todo.md": plan(fix)})
|
||||
merge("fix", "Fix six", {"a.py": "1\ny\n", "todo.md": plan("")})
|
||||
merge("fix", fix_title, {"a.py": "1\ny\n", "todo.md": plan("" if ships_fix else fix)})
|
||||
|
||||
def test_reads_each_cycles_route_from_its_own_outcomes_file(self):
|
||||
transcript = self.root / "t.jsonl"
|
||||
|
||||
+27
-5
@@ -33,6 +33,7 @@ override cannot be logged; 0 otherwise. `rule-hook overrides` exits 1 when git c
|
||||
checkout or the branch's reflog. Exit 1, a non-blocking error to Claude Code, on input it
|
||||
cannot read.
|
||||
"""
|
||||
import functools
|
||||
import json
|
||||
import os
|
||||
import pathlib
|
||||
@@ -41,18 +42,23 @@ import time
|
||||
import typing
|
||||
|
||||
from rule_hook.call import applied, Call, FILE_TOOLS, parsed_call, text
|
||||
from rule_hook.rules import Breach, check, Checked, command_breaches, file_breaches, rules_help
|
||||
from git_cli.git_command import commits
|
||||
from rule_hook.rules import Breach, check, Checked, command_breaches, file_breaches, rules_help, title_breaches
|
||||
from git_cli.git_command import CommitCall, commits
|
||||
from rule_hook.committed_files import committed_file_breaches
|
||||
from rule_hook.env_file import env_file_breaches
|
||||
from failure import Failure
|
||||
from git_cli.git_repo import git
|
||||
from rule_hook.git import guarded_git
|
||||
from project_config.main import located
|
||||
from rule_hook.override_log import Log, log_path, logged, print_overrides, write_override
|
||||
from project_config.settings import ProjectConfig, Unnamed
|
||||
from rule_hook.file_text import read
|
||||
from rule_hook.repeat_read import read_breaches
|
||||
from rule_hook.reviewer_report import report_breaches
|
||||
from rule_hook.reviewer_rung import reviewer_breaches, skill_breaches
|
||||
from rule_hook.round_cap import round_cap_breaches
|
||||
from command_lines.shell_command import simple_commands
|
||||
from project_config import templates
|
||||
from rule_hook.todo_check import todo_breaches
|
||||
|
||||
|
||||
@@ -119,9 +125,25 @@ def answer(checked: Checked, what: str, now: float) -> int:
|
||||
|
||||
|
||||
def bash_breaches(command: str, cwd: str, home: str) -> list[Breach]:
|
||||
"""The breaches of the command's own words, then of each commit it makes, then of the files those commits may take."""
|
||||
simples = simple_commands(command, cwd, home)
|
||||
found = commits(simples, home)
|
||||
in_commits = [breach for commit in found for breach in commit_breaches(commit, pathlib.Path(home))]
|
||||
in_files = [breach for directory in dict.fromkeys(commit.directory for commit in found) for breach in committed_file_breaches(directory)]
|
||||
round_cap = [breach for commit in found for breach in round_cap_breaches(commit, pathlib.Path(home))]
|
||||
todo = [breach for commit in found for breach in todo_breaches(commit.directory, pathlib.Path(home))]
|
||||
return command_breaches(command, simples, home) + round_cap + todo + in_files
|
||||
return command_breaches(command, simples) + in_commits + in_files
|
||||
|
||||
|
||||
def commit_breaches(commit: CommitCall, home: pathlib.Path) -> list[Breach]:
|
||||
"""The breaches of one commit: its title's and its round's, read through the title templates of the project's config, and its plan's. A config that cannot be read is a breach itself, since no title can then be checked."""
|
||||
config = located(commit.directory, home, functools.partial(git, guarded=True))
|
||||
unread = []
|
||||
if isinstance(config, Failure) and not isinstance(config, Unnamed):
|
||||
unread = [Breach("commit-title", f"the project's config cannot be read, so the title is not checked against its template: {config.reason}", commit.directory)]
|
||||
titles = config.titles if isinstance(config, ProjectConfig) else templates.BARE
|
||||
return unread + title_breaches(commit, titles, isinstance(config, ProjectConfig) and on_item_branch(commit.directory, config.branch)) + round_cap_breaches(commit, titles) + todo_breaches(commit.directory, home)
|
||||
|
||||
|
||||
def on_item_branch(directory: str, template: str) -> bool:
|
||||
"""Whether directory's checkout is on a branch that fits template, the config's `branch`: a plan item's branch, whose commits carry the item's ID. Any other branch, such as a release review's, has no item to give {id}."""
|
||||
branch = guarded_git(directory, "symbolic-ref", "--quiet", "--short", "HEAD")
|
||||
return not isinstance(branch, Failure) and templates.branch_fits(template, branch)
|
||||
|
||||
@@ -1,25 +1,20 @@
|
||||
import functools
|
||||
import pathlib
|
||||
|
||||
from rule_hook.rules import Breach
|
||||
from review_rules.round_titles import cap, past_cap, round_counts, round_pass
|
||||
from project_config.main import commit_title
|
||||
from git_cli.git_command import CommitCall
|
||||
from failure import Failure
|
||||
from git_cli import git_repo
|
||||
from review_rules.review_passes import PASSES
|
||||
from project_config import templates
|
||||
from project_config.templates import Titles
|
||||
|
||||
|
||||
def round_cap_breaches(commit: CommitCall, home: pathlib.Path) -> list[Breach]:
|
||||
"""A breach where the commit's title names no pass, or takes its pass past the cap, counted with the branch's earlier round commits. Each title is read as its summary in the project's `commit-title` template."""
|
||||
template = commit_title(commit.directory, home, functools.partial(git_repo.git, guarded=True))
|
||||
summaries = [templates.summary_of(template, message.strip()) for message in commit.messages]
|
||||
def round_cap_breaches(commit: CommitCall, titles: Titles) -> list[Breach]:
|
||||
"""A breach where the commit's title names no pass, or takes its pass past the cap, counted with the branch's earlier round commits. Each title is read as its summary in titles, the project's title templates."""
|
||||
summaries = [titles.summary(message.strip()) for message in commit.messages]
|
||||
named = [(name, summary) for summary in summaries if (name := round_pass(summary))]
|
||||
unknown = [Breach("round-cap", f"`{name}` names no larv-review pass, so its rounds would never reach a cap; name one of: {', '.join(PASSES)}", commit.directory) for name, _ in named if name not in PASSES]
|
||||
if unknown or not named:
|
||||
return unknown
|
||||
earlier = [templates.summary_of(template, title) for title in earlier_titles(commit.directory, commit.amends)]
|
||||
earlier = [titles.summary(title) for title in earlier_titles(commit.directory, commit.amends)]
|
||||
return [Breach("round-cap", refusal(name, message, earlier), commit.directory) for name, message in named if past_cap(message, earlier)]
|
||||
|
||||
|
||||
|
||||
+19
-20
@@ -1,15 +1,11 @@
|
||||
import dataclasses
|
||||
import functools
|
||||
import pathlib
|
||||
import posixpath
|
||||
import re
|
||||
import typing
|
||||
|
||||
from review_rules.round_titles import CAP, COUNTS, EXAMPLE, lacks_counts, OPENING, RELEASE_REVIEW_CAP
|
||||
from project_config.main import commit_title
|
||||
from git_cli.git_command import commits
|
||||
from git_cli.git_command import CommitCall
|
||||
from run_heavy.capped_docker import finds_this_docker
|
||||
from git_cli.git_repo import git
|
||||
from rule_hook.heavy_command import heavy
|
||||
from command_lines.shell_command import launched, Simple
|
||||
from review_rules.review_folder import REPORTS
|
||||
@@ -37,8 +33,8 @@ RULES: dict[RuleName, Rule] = {
|
||||
"git commit takes its message as one -m with no line break; -F, a second -m and a heredoc are blocked",
|
||||
),
|
||||
"commit-title": Rule(
|
||||
"a commit's title fits the `commit-title` template the project's config names, such as `PAY-{id} - {summary}`, so the project's log reads as its owners write it",
|
||||
"the -m of a git commit in a checkout whose config sets `commit-title`; a round title's `Answer <pass> round <n>:` is the template's {summary}",
|
||||
"a commit's title fits the `commit-title` template the project's config names, such as `[{id}] {summary}`, so the project's log reads as its owners write it",
|
||||
"the -m of a git commit in a checkout whose config sets `commit-title`, on a branch that fits the config's `branch` template; on any other branch, as for a chunk with no plan item, the title may be the bare summary. A round title, from `Answer <pass> round <n>:` to its end, is the template's {summary}. While the config cannot be read, every commit is blocked",
|
||||
),
|
||||
"docker-run-memory": Rule(
|
||||
"a container made with docker run or docker create has a memory limit and a swap limit, as large as its work needs, such as `--memory 4g --memory-swap 4g`, so a runaway container fails alone instead of starving the machine; a swap limit equal to the memory limit keeps it out of swap",
|
||||
@@ -156,9 +152,8 @@ def check(breaches: list[Breach], written: str, markdown: bool, bash: bool) -> C
|
||||
return Checked(messages, bool(blocking), [(breach, grant[breach.rule]) for breach, grant in zip(breaches, grants) if breach.rule in grant])
|
||||
|
||||
|
||||
def command_breaches(command: str, simples: list[Simple], home: str) -> list[Breach]:
|
||||
def command_breaches(command: str, simples: list[Simple]) -> list[Breach]:
|
||||
breaches = []
|
||||
found = commits(simples, home)
|
||||
publishing = [simple for simple in simples if posixpath.basename(simple.words[0]) in ("chunk-pr", "gh", "git", "tea")]
|
||||
if publishing and ATTRIBUTION.search(command):
|
||||
breaches.append(Breach("no-ai-attribution", "the command carries an attribution", publishing[0].directory))
|
||||
@@ -167,17 +162,21 @@ def command_breaches(command: str, simples: list[Simple], home: str) -> list[Bre
|
||||
breaches.append(Breach("run-heavy", f"run `{' '.join(simple.words)[:80]}` under `~/.claude/bin/run-heavy`, in the background", simple.directory))
|
||||
if unlimited_container(simple.words):
|
||||
breaches.append(Breach("docker-run-memory", f"give `{' '.join(simple.words)[:80]}` a memory limit and a swap limit as large as its work needs", simple.directory))
|
||||
for commit in found:
|
||||
if commit.from_file:
|
||||
breaches.append(Breach("commit-one-line", "pass the message as one -m '<line>', not from a file", commit.directory))
|
||||
elif len(commit.messages) > 1 or any("\n" in message.strip() for message in commit.messages):
|
||||
breaches.append(Breach("commit-one-line", "pass the message as one -m '<line>', with no heredoc, second -m or newline", commit.directory))
|
||||
template = commit_title(commit.directory, pathlib.Path(home), functools.partial(git, guarded=True))
|
||||
# A message of several lines breaks commit-one-line above, which says how to fix it.
|
||||
if misfit := [message for message in commit.messages[:1] if "\n" not in message.strip() and not templates.fits(template, message.strip())]:
|
||||
breaches.append(Breach("commit-title", f"title the commit as the project's config asks, `{template}`, where {{id}} is the ID of the chunk's first item; `{misfit[0].strip()[:80]}` doesn't fit", commit.directory))
|
||||
if any(lacks_counts(templates.summary_of(template, message.strip())) for message in commit.messages):
|
||||
breaches.append(Breach("round-title-counts", f"open the summary after the round's colon with `{COUNTS}`, where <j> is at most <k> + <m>", commit.directory))
|
||||
return breaches
|
||||
|
||||
|
||||
def title_breaches(commit: CommitCall, titles: templates.Titles, held: bool) -> list[Breach]:
|
||||
"""The breaches of the commit's message, read through titles, the project's title templates. held is whether the title must fit the commit template: it must on a branch that fits the config's `branch` template."""
|
||||
breaches = []
|
||||
if commit.from_file:
|
||||
breaches.append(Breach("commit-one-line", "pass the message as one -m '<line>', not from a file", commit.directory))
|
||||
elif len(commit.messages) > 1 or any("\n" in message.strip() for message in commit.messages):
|
||||
breaches.append(Breach("commit-one-line", "pass the message as one -m '<line>', with no heredoc, second -m or newline", commit.directory))
|
||||
# A message of several lines breaks commit-one-line above, which says how to fix it.
|
||||
if held and (misfit := [message for message in commit.messages[:1] if "\n" not in message.strip() and not templates.fits(titles.commit, message.strip())]):
|
||||
breaches.append(Breach("commit-title", f"title the commit as the project's config asks, `{titles.commit}`, where {{id}} is the ID of the chunk's first item; `{misfit[0].strip()[:80]}` doesn't fit", commit.directory))
|
||||
if any(lacks_counts(titles.summary(message.strip())) for message in commit.messages):
|
||||
breaches.append(Breach("round-title-counts", f"open the summary after the round's colon with `{COUNTS}`, where <j> is at most <k> + <m>", commit.directory))
|
||||
return breaches
|
||||
|
||||
|
||||
|
||||
@@ -14,7 +14,8 @@ import unittest.mock
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from rule_hook.repeat_read import Asked, modified, read_breaches, result_lines
|
||||
from rule_hook.rules import blocks, Breach, check, command_breaches, file_breaches, overrides, RuleName, RULES
|
||||
from project_config.templates import BARE, Titles
|
||||
from rule_hook.rules import blocks, Breach, check, command_breaches, file_breaches, overrides, RuleName, RULES, title_breaches
|
||||
from rule_hook.main import breaches_of
|
||||
from rule_hook.call import Call, parsed_call
|
||||
from git_cli.git_command import commit_message, CommitCall, commits
|
||||
@@ -40,8 +41,14 @@ def committed(command: str, cwd: str = "/r") -> list[CommitCall]:
|
||||
return commits(simple_commands(command, cwd, "/h"), "/h")
|
||||
|
||||
|
||||
def breaches(command: str, titles: Titles = BARE, held: bool = False) -> list[Breach]:
|
||||
"""The command's breaches and those of each commit's title, read through titles; held is whether the title must fit the commit template."""
|
||||
simples = simple_commands(command, "/r", "/h")
|
||||
return command_breaches(command, simples) + [breach for commit in commits(simples, "/h") for breach in title_breaches(commit, titles, held)]
|
||||
|
||||
|
||||
def checked(command: str) -> list[str]:
|
||||
return rules(command_breaches(command, simple_commands(command, "/r", "/h"), "/h"))
|
||||
return rules(breaches(command))
|
||||
|
||||
|
||||
def hook(call: dict, cwd: str, env: dict[str, str] | None = None) -> subprocess.CompletedProcess:
|
||||
@@ -112,7 +119,7 @@ class CommandBreaches(unittest.TestCase):
|
||||
self.assertEqual(checked("git commit -m 'Answer stability round 1: fix the parser'"), ["round-title-counts"])
|
||||
self.assertEqual(checked("git commit -m 'Answer stability round 1: 1 🔴, 2 🟡; fix the parser'"), ["round-title-counts"])
|
||||
command = "git commit -m 'Answer stability round 1: fix the parser'"
|
||||
self.assertEqual(command_breaches(command, simple_commands(command, "/r", "/h"), "/h"), [Breach("round-title-counts", "open the summary after the round's colon with `<k> 🔴, <m> 🟡 (<j> misread);`, where <j> is at most <k> + <m>", "/r")])
|
||||
self.assertEqual(breaches(command), [Breach("round-title-counts", "open the summary after the round's colon with `<k> 🔴, <m> 🟡 (<j> misread);`, where <j> is at most <k> + <m>", "/r")])
|
||||
self.assertEqual(checked("git commit --allow-empty -m 'Answer prose round 2: 0 🔴, 0 🟡 (0 misread)'"), [])
|
||||
self.assertEqual(checked("git commit -m 'Answer stability round 1: 1 🔴, 2 🟡 (1 misread); fix the parser'"), [])
|
||||
self.assertEqual(checked("git commit -m 'Answer the question in the README'"), [])
|
||||
@@ -143,7 +150,20 @@ class CommandBreaches(unittest.TestCase):
|
||||
self.assertEqual(checked(f"grep -rn '{TRAILER}' ."), [])
|
||||
|
||||
def test_a_commit_breach_names_the_commit_s_checkout(self):
|
||||
self.assertEqual(command_breaches("cd w && git commit -m a -m b", simple_commands("cd w && git commit -m a -m b", "/r", "/h"), "/h")[0].directory, "/r/w")
|
||||
self.assertEqual(breaches("cd w && git commit -m a -m b")[0].directory, "/r/w")
|
||||
|
||||
def test_a_title_must_fit_the_commit_template_only_where_the_branch_holds_it_to_it(self):
|
||||
titles = Titles("PAY-{id} - {summary}", "{summary}")
|
||||
self.assertEqual(breaches("git commit -m 'Release review of 0.3.0'", titles, held=True), [Breach("commit-title", "title the commit as the project's config asks, `PAY-{id} - {summary}`, where {id} is the ID of the chunk's first item; `Release review of 0.3.0` doesn't fit", "/r")])
|
||||
self.assertEqual(breaches("git commit -m 'Release review of 0.3.0'", titles), [])
|
||||
self.assertEqual(breaches("git commit -m 'PAY-7 - Tidy'", titles, held=True), [])
|
||||
|
||||
def test_a_round_title_is_read_through_either_template_for_its_counts(self):
|
||||
titles = Titles("PAY-{id} - {summary}", "fix: {summary}")
|
||||
for title in ("PAY-7 - Answer prose round 1: fix", "fix: Answer prose round 1: fix", "Answer prose round 1: fix"):
|
||||
with self.subTest(title):
|
||||
self.assertEqual(rules(breaches(f"git commit -m '{title}'", titles)), ["round-title-counts"])
|
||||
self.assertEqual(breaches("git commit -m 'PAY-7 - Answer prose round 1: 0 🔴, 0 🟡 (0 misread)'", titles, held=True), [])
|
||||
|
||||
|
||||
class FileBreaches(unittest.TestCase):
|
||||
@@ -1029,6 +1049,7 @@ class Hook(unittest.TestCase):
|
||||
def test_a_commit_is_titled_by_the_configs_template_and_its_round_title_read_through_it(self):
|
||||
config = configured(self, pathlib.Path(self.repo)) / "config.toml"
|
||||
config.write_text(config.read_text() + 'commit-title = "PAY-{id} - {summary}"\n')
|
||||
git(self.repo, "checkout", "-q", "-b", "item-7")
|
||||
for title in ["PAY-7 - Answer stability round 1: 1 🔴, 0 🟡 (0 misread); a", "PAY-7 - Answer stability round 2: 0 🔴, 1 🟡 (0 misread); c"]:
|
||||
git(self.repo, "commit", "-q", "--allow-empty", "-m", title)
|
||||
past = self.round_commit("PAY-7 - Answer stability round 2: 0 🔴, 0 🟡 (0 misread); d")
|
||||
@@ -1041,6 +1062,35 @@ class Hook(unittest.TestCase):
|
||||
self.assertEqual(self.round_commit("PAY-7 - Answer prose round 1: 0 🔴, 0 🟡 (0 misread); x").returncode, 0)
|
||||
self.assertEqual(self.round_commit("Tidy # rule-override commit-title: the client asked for this title").returncode, 0)
|
||||
|
||||
def test_a_commit_on_a_branch_that_doesnt_fit_the_configs_branch_template_takes_a_bare_title(self):
|
||||
config = configured(self, pathlib.Path(self.repo)) / "config.toml"
|
||||
config.write_text(config.read_text() + 'commit-title = "PAY-{id} - {summary}"\nbranch = "feature/PAY-{id}"\n')
|
||||
git(self.repo, "checkout", "-q", "-b", "release-review-0.3.0")
|
||||
self.assertEqual(self.round_commit("Release review of 0.3.0", "--allow-empty ").returncode, 0)
|
||||
self.assertIn("Blocked by rule round-title-counts", self.round_commit("PAY-7 - Answer prose round 1: fix").stderr)
|
||||
git(self.repo, "checkout", "-q", "-b", "feature/PAY-7")
|
||||
held = self.round_commit("Release review of 0.3.0", "--allow-empty ")
|
||||
self.assertEqual(held.returncode, 2)
|
||||
self.assertIn("Blocked by rule commit-title: title the commit as the project's config asks, `PAY-{id} - {summary}`", held.stderr)
|
||||
self.assertEqual(self.round_commit("PAY-7 - Tidy").returncode, 0)
|
||||
|
||||
def test_a_commit_is_refused_naming_the_fault_while_a_config_cannot_be_read(self):
|
||||
config = configured(self, pathlib.Path(self.repo)) / "config.toml"
|
||||
config.write_text(config.read_text() + 'commit-title = "PAY-{id}"\n')
|
||||
refused = self.round_commit("PAY-7 - Tidy")
|
||||
self.assertEqual(refused.returncode, 2)
|
||||
self.assertIn("Blocked by rule commit-title: the project's config cannot be read, so the title is not checked against its template: ", refused.stderr)
|
||||
self.assertIn("`commit-title` is 'PAY-{id}'", refused.stderr)
|
||||
config.write_text(config.read_text().replace('commit-title = "PAY-{id}"\n', ""))
|
||||
other = config.parents[1] / "other" / "config.toml"
|
||||
other.parent.mkdir()
|
||||
other.write_text("checkout = [")
|
||||
refused = self.round_commit("Tidy")
|
||||
self.assertEqual(refused.returncode, 2)
|
||||
self.assertIn(f"cannot read {other}", refused.stderr)
|
||||
other.unlink()
|
||||
self.assertEqual(self.round_commit("Tidy").returncode, 0)
|
||||
|
||||
def test_a_commit_while_an_unranked_todo_has_changes_is_blocked(self):
|
||||
configured(self, pathlib.Path(self.repo))
|
||||
pathlib.Path(self.repo, "docs").mkdir()
|
||||
|
||||
@@ -95,13 +95,13 @@ import sys
|
||||
|
||||
from score_outcomes.anchors import anchor_lines, Anchors, ANCHORS_PATH, parse_anchors
|
||||
from branch_chunks.read import branch_chunks, unsupported
|
||||
from project_config.main import commit_title, project
|
||||
from git_cli.git_repo import default_branch, full_history, git, top
|
||||
from failure import Failure
|
||||
from score_outcomes.results import file_lines, fixed_later, item_text, misreads, nearest, render, report, Result, results_of
|
||||
from release_plan.todo_table import item_details, LEVELS, risk, TOP_SCORE
|
||||
from text_files.markdown_text import listed
|
||||
from release_plan.named_code import named_files
|
||||
from project_config.main import project, title_templates
|
||||
from transcript_archive.location import project_archive
|
||||
from score_outcomes.reversals import reversal_lines
|
||||
from record_store.stores import store
|
||||
@@ -194,7 +194,10 @@ def read_results(default: str) -> list[Result] | Failure:
|
||||
if isinstance(root, Failure):
|
||||
return root
|
||||
run = functools.partial(git, cwd=root)
|
||||
chunks = branch_chunks(default, run, commit_title(None, pathlib.Path.home()))
|
||||
templates = title_templates(None, pathlib.Path.home())
|
||||
if isinstance(templates, Failure):
|
||||
return templates
|
||||
chunks = branch_chunks(default, run, templates)
|
||||
if isinstance(chunks, Failure):
|
||||
return chunks
|
||||
empty_tree = run("hash-object", "-t", "tree", os.devnull)
|
||||
|
||||
@@ -437,6 +437,23 @@ class ScoreOutcomesTool(unittest.TestCase):
|
||||
self.assertIn(f"- Item 5, R 4, S 6, C 8: 1 line in 1 file, at least 0 rounds past each pass's first, findings unknown, 0 later fixes; committed 2026-10-12T09:00:00Z in {drop}, never replayed, so perhaps part of a pull request. **Then this.**", ran.stdout)
|
||||
self.assertNotIn("by rebase", ran.stdout)
|
||||
|
||||
def test_reads_a_drop_title_through_the_configs_title_template(self):
|
||||
config = pathlib.Path(self.env["HOME"], ".claude-projects", "proj", "config.toml")
|
||||
config.write_text(config.read_text() + 'commit-title = "PAY-{id} - {summary}"\n')
|
||||
self.commit("PAY-5 - Drop item 5: moot", {"b.py": "1\n", "todo.md": todo(FIRST)})
|
||||
self.git("switch", "-q", "-c", "chunk")
|
||||
self.commit("PAY-4 - Do it", {"a.py": "1\n", "todo.md": todo()})
|
||||
self.git("switch", "-q", "main")
|
||||
self.git("merge", "-q", "--no-ff", "-m", "Merge chunk", "chunk")
|
||||
ran = self.run_tool("1", "2", "1", "3")
|
||||
self.assertEqual(ran.returncode, 0, ran.stderr)
|
||||
self.assertIn("- Item 4,", ran.stdout)
|
||||
self.assertNotIn("Item 5", ran.stdout)
|
||||
config.write_text(config.read_text() + 'branch = "item"\n')
|
||||
ran = self.run_tool("1", "2", "1", "3")
|
||||
self.assertEqual((ran.returncode, ran.stdout), (1, ""))
|
||||
self.assertIn("`branch` is 'item'", ran.stderr)
|
||||
|
||||
def test_labels_a_merge_merge_even_when_its_author_and_commit_times_are_equal(self):
|
||||
self.git("switch", "-q", "-c", "chunk")
|
||||
self.commit("Do it", {"a.py": "1\n", "todo.md": todo(SECOND)}, at="2026-10-13T09:00:00Z", authored="2026-10-13T09:00:00Z")
|
||||
|
||||
+7
-5
@@ -280,12 +280,14 @@ Messages keep each file's usual name, such as `todo.md`, as its label, since the
|
||||
|
||||
2026-11-14, larv-review. Serves goal 1.6: a client's team reads its docs, Jira text, commits and pull requests in its own language and format. Valid while one language and one template per title serve a project.
|
||||
|
||||
- **The spelling is benched.** Three fresh readers, seated as the person who writes a client's `config.toml`, each picked brace templates, these four keys and the language's English name (`"Swedish"`) over `%`-codes, regular expressions and language codes.
|
||||
- **`{id}` is the ID of the chunk's first plan item, and `{summary}` the title a project without templates would have.** A title template holds `{summary}` once and may hold `{id}`; `branch` holds `{id}` and no `{summary}`. Any other brace is a fault the config's reader names: no template needs a literal brace, so there is no escape to learn.
|
||||
- **A title that doesn't fit the template is its own summary.** History from before a template was set still reads, so every tool that parses a title, such as a round count or `Drop item`, parses the summary (`bin/project_config/templates.py`, `summary_of`). rule-hook's `commit-title` rule refuses a new commit that doesn't fit, and `chunk-pr` a pull request title.
|
||||
- **A bench of readers picked the spelling.** Three fresh readers, seated as the person who writes a client's `config.toml`, each picked brace templates, these four keys and the language's English name (`"Swedish"`) over `%`-codes, regular expressions and language codes.
|
||||
- **`{id}` is the ID of the chunk's first plan item, `todo.md`'s number while the plan is `todo.md`, and `{summary}` the title a project without templates would have.** A title template holds `{summary}` once and may hold `{id}`; `branch` holds `{id}` and no `{summary}`. A title template keeps text between `{id}` and `{summary}`, so a title splits one way, and has no space at its start or end and no control character. Any other brace is a fault `project-config` names: no template needs a literal brace, so there is no escape to learn.
|
||||
- **A tool reads a title as its summary: by `commit-title`, then by `pull-request-title`, then whole.** A tool that looks for a round title or a `Drop item` title looks in the summary (`bin/project_config/templates.py`, `Titles`). The pull request's template is tried because a squash merge titles the commit as the pull request. A title that fits neither is its own summary, so history from before a template was set still reads.
|
||||
- **A title must fit its template only on a branch that fits `branch`.** There rule-hook's `commit-title` rule refuses a commit that doesn't fit, and `chunk-pr` a pull request title. A chunk without a plan item, such as a release review, has no ID to fill `{id}`; its branch doesn't fit, and its titles are the summary alone.
|
||||
- **A config with a fault stops the work.** rule-hook refuses every commit while the project's config cannot be read, and the tools that read titles fail naming the fault: a title read by the wrong template would miscount rounds in silence.
|
||||
- **The worktree is named after the branch**, `<checkout>-<branch>` with each `/` written `-`, so `feature/{id}` gets one folder beside the checkout.
|
||||
- **The language covers what the project's readers read**: docs, comments, tickets, and the summary a title carries. What this setup's tools parse stays English: the round titles' fixed words, `todo.md`'s table, the review reports and chat with lilleman.
|
||||
- **`deploy-release` titles its commit `Cut release <version>` whatever the template**, since a release has no plan item to give `{id}`, and the tool finds that commit again by its exact title.
|
||||
- **The language covers what the project's readers read**: docs, comments, tickets, and the summary a title carries. `CLAUDE.md` → "Prose" lists what stays English.
|
||||
- **`deploy-release` titles its commit `Cut release <version>` whatever the template**, since a release has no plan item to give `{id}`, and the tool finds that commit again by its exact title. It reads its clone's other titles whole, as no project's config names the clone.
|
||||
|
||||
## review: a release review fixes its findings in the release it reviews, and files under that release only a finding that needs a human answer, adds a feature or outlasts its five rounds
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
The full rules; `~/.claude/CLAUDE.md` → "Prose" keeps a core of them for the worker.
|
||||
|
||||
Everything written — chat, commit messages, comments, docs, code — is in **English**. Where a project's config names another `language`, which `~/.claude/bin/project-config language` prints, the prose that project's readers see is in that language instead: its docs, comments, commit messages, pull requests and tracker text. Chat, names in code, and the fixed words a tool reads in a title, such as `Answer <pass> round <n>:`, stay English. Prose meets four priorities, in this order. When two pull against each other, the higher one wins.
|
||||
Everything written — chat, commit messages, comments, docs, code — is in **English**. Where a project's config names another `language`, which `~/.claude/bin/project-config language` prints, the prose that project's readers see is in that language instead: its docs, comments, commit messages, pull requests and tracker text. These stay English: chat, names in code, a reviewer's report, and what a tool reads, which is the fixed words of a title, such as `Answer <pass> round <n>:`, `todo.md`'s table, and a record's headings, such as `## Unreleased`. Prose meets four priorities, in this order. When two pull against each other, the higher one wins.
|
||||
|
||||
1. **Easy to understand.** A reader with little time gets it on one read. Keep each sentence to one idea. Explain a term before using it, or use a plainer word. Never fold a clause into a noun phrase to save words. BANNED: `An empty earliest unreleased release with nothing shipped toward it is planned as this chunk`. GOOD: `When the next release has no items and no work has landed towards it, plan it.`
|
||||
2. **Most important first**, judged by what this document's reader wants to know first. Put the most important section first. Within each section, put the most important paragraph first, and within each list the most important item. Order matters most in long documents; in a short one, don't spend a fix on it.
|
||||
|
||||
Reference in New Issue
Block a user