Merge remote-tracking branch 'origin/main' into item-408
This commit is contained in:
@@ -2,6 +2,7 @@
|
||||
|
||||
## Unreleased
|
||||
|
||||
- `todo-item add` and `todo-item edit --detail` refuse a detail whose `Touches:` list touch-predictions cannot read, and `rank_todo.py --check` fails on each item holding one, so rule-hook refuses a commit of such a plan: after updating, run `~/.claude/bin/rank_todo.py --check` in each project and fix each list it names.
|
||||
- loop-claude hands each worker's claude a Bash output ceiling of 6,000 characters that saves a longer result to a file, rule-hook refuses a Read of a session transcript under ~/.claude/projects, and review-replay takes --bash-ceiling and --read-limit to test such a limit against archived review rounds.
|
||||
- do-epic picks each epic item's repo, or that it is Claude's work or a human task, by repo-rule.md and a headless claude call, records the pick as a label on the issue and reads it back without a new call; where the rule leaves it unclear it returns a question for the human. The epic backends gain a label write.
|
||||
- judge-replay <model> --offline replays every archived verdict through a "?" rule, a decision table and a classifier trained on the archive, with no judge call, and counts the interrupts each misses.
|
||||
|
||||
@@ -223,7 +223,7 @@ Install puts only `loop-claude` on `PATH`; call the others by their path, such a
|
||||
- `machine_load/` takes the machine's heavy slots, its shared lock files, for `run_heavy` and `adf_codec`, and reads the memory share that loop-claude waits for. It also gives `mutate_changes` a slot's CPU count.
|
||||
- `model_routing/` holds the shipped routing ladder (`routing-ladder.json`) and its steps (`ladder.py`), and reads a ladder from that file or a project's own (`ladder_file.py`), for loop-claude, `rule_hook`, `do_epic`, both replay tools and `subagent-rung`. It finds a project's config folder through `project_config`. It also holds the list prices, which `routing_figures` and `transcript_archive` read.
|
||||
- `notifier/` sends the human a DM through the notifier a project's config names, for `notify` and for loop-claude through `loop_effects`. Its backends are `mattermost.py` and `slack.py`.
|
||||
- `plan/` is the plan's core, and imports neither `plan_store` nor `release_plan`. It holds an item and the items table's format (`todo_table.py`), releases (`release.py`), the ranking (`ranking.py`, with its score formula in `formula.py` and its blocker order in `blockers.py`), the paths an item's text names (`named_paths.py`) and `citations.py`, which holds `todo.md` and `docs/decisions.md` to each other. `goals_file.py` reads the goals file's sections, goals and goal weights, for the ranking and for `loop_claude`'s premises.
|
||||
- `plan/` is the plan's core, and imports neither `plan_store` nor `release_plan`. It holds an item and the items table's format (`todo_table.py`), releases (`release.py`), the ranking (`ranking.py`, with its score formula in `formula.py` and its blocker order in `blockers.py`), the paths an item's text names (`named_paths.py`), an item's `Touches:` prediction and where two overlap (`touches.py`), and `citations.py`, which holds `todo.md` and `docs/decisions.md` to each other. `goals_file.py` reads the goals file's sections, goals and goal weights, for the ranking and for `loop_claude`'s premises.
|
||||
- `plan_store/` reads and writes a project's plan through the store the project's config names (`stores.py`). Every backend meets `plans.py`'s `PlanStore`: a markdown file (`todo_md.py`, which also ranks and checks the file in place, with its text edits in `markdown_edits.py`) or a Jira epic (`jira_epic.py`). `scoring.py` reads the goal weights that both backends rank by. `contract.py` holds the tests every backend that writes must pass; `jira_epic.py` doesn't yet, and its own tests stand in for Jira. `fakes.py` holds a plan in memory.
|
||||
- `rank_todo.py`, `settings_filter.py` and `statusline.py` are tools of one file each, tested beside them.
|
||||
- `record_store/` reads and writes a project's records, each through the store the project's config names (`stores.py`): a markdown file, a Confluence Cloud page (`confluence_page.py`), or, for the goals, a Jira epic's description (`jira_description.py`). `contract.py` holds the tests every backend must pass, and `fakes.py` a store in memory that the tests of other tools use.
|
||||
|
||||
@@ -14,7 +14,7 @@ from failure import Failure
|
||||
from project_config.main import located
|
||||
from loop_claude.loop.reload import LoopRun
|
||||
from release_plan.next_chunk import NextChunk, NoItem, planned
|
||||
from touch_predictions.prediction import overlaps, predicted, Touches
|
||||
from plan.touches import overlaps, predicted, Touches
|
||||
from loop_state.paths import Paths
|
||||
from transcript_archive.project_key import project_key
|
||||
from release_plan.release_standing import project_plan
|
||||
|
||||
@@ -0,0 +1,167 @@
|
||||
import pathlib
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from adf_codec import convert
|
||||
from failure import Failure
|
||||
from plan.touches import overlaps, Part, predicted, rendered, together
|
||||
|
||||
DETAIL = """A planning call.
|
||||
|
||||
Touches:
|
||||
|
||||
- `bin/a.py`: `main`, `Plan.branch` (small)
|
||||
- `README.md`: `## Goals, and (more): things`
|
||||
- `bin/run.sh`: lines 10-20
|
||||
- `docs/new.md`
|
||||
|
||||
More prose, with `bin/b.py` named.
|
||||
"""
|
||||
|
||||
needs_docker = unittest.skipIf(shutil.which("docker") is None or subprocess.run(["docker", "info"], capture_output=True, timeout=20).returncode != 0, "adf_codec runs in a container, which needs a docker daemon")
|
||||
|
||||
|
||||
def text(words: str, code: bool = False) -> dict:
|
||||
return {"type": "text", "text": words, **({"marks": [{"type": "code"}]} if code else {})}
|
||||
|
||||
|
||||
def bullet_of(*spans: dict) -> dict:
|
||||
return {"type": "listItem", "attrs": {"localId": "i"}, "content": [{"type": "paragraph", "attrs": {"localId": "p"}, "content": list(spans)}]}
|
||||
|
||||
|
||||
# A Touches list as someone types it in Jira's editor: a paragraph, then a bulleted list whose paths and names carry the code mark.
|
||||
JIRA_TOUCHES = {"type": "doc", "version": 1, "content": [
|
||||
{"type": "paragraph", "attrs": {"localId": "a"}, "content": [text("A planning call.")]},
|
||||
{"type": "paragraph", "attrs": {"localId": "b"}, "content": [text("Touches:")]},
|
||||
{"type": "bulletList", "attrs": {"localId": "c"}, "content": [
|
||||
bullet_of(text("bin/a.py", True), text(": "), text("main", True), text(", "), text("Plan.branch", True), text(" (small)")),
|
||||
bullet_of(text("a`b.md", True), text(": "), text("## The `foo` tool", True), text(" (small)"), text(", "), text("`x`", True)),
|
||||
bullet_of(text("bin/run.sh", True), text(": lines 10-20")),
|
||||
bullet_of(text("docs/new.md", True)),
|
||||
]},
|
||||
{"type": "paragraph", "attrs": {"localId": "d"}, "content": [text("More prose.")]},
|
||||
]}
|
||||
|
||||
|
||||
class PredictedTest(unittest.TestCase):
|
||||
def test_reads_each_bullet_of_the_touches_list(self) -> None:
|
||||
self.assertEqual(predicted(DETAIL), {
|
||||
"bin/a.py": (Part("main"), Part("Plan.branch", small=True)),
|
||||
"README.md": (Part("## Goals, and (more): things"),),
|
||||
"bin/run.sh": (Part("lines 10-20"),),
|
||||
"docs/new.md": (),
|
||||
})
|
||||
|
||||
def test_a_detail_without_the_list_predicts_nothing(self) -> None:
|
||||
self.assertIsNone(predicted("Only prose, with `bin/a.py` named."))
|
||||
|
||||
def test_a_bullet_it_cannot_read_is_a_failure_that_quotes_it(self) -> None:
|
||||
for bullet in ("- bin/a.py: main", "- `bin/a.py`: main", "- `bin/a.py`: lines 20-10", "- `bin/a.py`: `main` `other`"):
|
||||
with self.subTest(bullet):
|
||||
found = predicted(f"Touches:\n\n{bullet}\n")
|
||||
assert isinstance(found, Failure)
|
||||
self.assertIn(bullet, found.reason)
|
||||
|
||||
def test_an_empty_list_is_a_failure(self) -> None:
|
||||
self.assertIsInstance(predicted("Touches:\n\nProse.\n"), Failure)
|
||||
found = predicted("Touches:\n")
|
||||
assert isinstance(found, Failure)
|
||||
self.assertEqual(found.reason, "no bullet follows `Touches:`")
|
||||
|
||||
def test_reads_a_list_right_under_its_label_a_one_line_range_and_a_name_of_any_letters(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `a.py`: `Xray`, lines 5-5\n"), {"a.py": (Part("Xray"), Part("lines 5-5"))})
|
||||
|
||||
def test_rendered_reads_back(self) -> None:
|
||||
touches = predicted(DETAIL)
|
||||
assert isinstance(touches, dict)
|
||||
self.assertEqual(predicted(f"Touches:\n\n{rendered(touches)}\n"), touches)
|
||||
|
||||
def test_a_name_that_holds_backticks_takes_a_longer_run_with_a_space_inside_each_end(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `a.md`: `` ## The `foo` tool `` (small), ``` `` ```, `` `x` ``\n"), {"a.md": (Part("## The `foo` tool", small=True), Part("``"), Part("`x`"))})
|
||||
self.assertEqual(rendered({"a.md": (Part("## The `foo` tool", small=True), Part("``"))}), "- `a.md`: `` ## The `foo` tool `` (small), ``` `` ```")
|
||||
|
||||
def test_a_longer_run_without_padding_spaces_is_the_text_between_its_runs(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- ``a`b.md``: ``## The `foo` tool`` (small), ``` `` ```, `` `x` ``\n"), {"a`b.md": (Part("## The `foo` tool", small=True), Part("``"), Part("`x`"))})
|
||||
|
||||
def test_a_longer_run_with_a_space_at_one_end_only_keeps_it(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `a.md`: `` x``, ``y ``, `` a ``\n"), {"a.md": (Part(" x"), Part("y "), Part("a"))})
|
||||
|
||||
@needs_docker
|
||||
def test_a_list_written_in_markdown_and_read_back_from_a_jira_description_reads_as_written(self) -> None:
|
||||
description = convert.markdown_to_adf(DETAIL)
|
||||
assert isinstance(description, dict)
|
||||
self.assertEqual(predicted(convert.adf_to_markdown(description)), predicted(DETAIL))
|
||||
|
||||
@needs_docker
|
||||
def test_a_list_typed_in_jiras_editor_reads_as_its_files_and_parts(self) -> None:
|
||||
read = convert.adf_to_markdown(JIRA_TOUCHES)
|
||||
self.assertEqual(predicted(read), {
|
||||
"bin/a.py": (Part("main"), Part("Plan.branch", small=True)),
|
||||
"a`b.md": (Part("## The `foo` tool", small=True), Part("`x`")),
|
||||
"bin/run.sh": (Part("lines 10-20"),),
|
||||
"docs/new.md": (),
|
||||
})
|
||||
|
||||
def test_a_name_ends_only_at_a_run_as_long_as_the_one_that_opens_it(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `a.md`: `` a ``` b ``, `c``d`\n"), {"a.md": (Part("a ``` b"), Part("c``d"))})
|
||||
|
||||
def test_a_path_holds_any_character_and_a_single_backtick_keeps_a_names_spaces(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `my file.md`: ` x `\n- `` a`b.md ``\n"), {"my file.md": (Part(" x "),), "a`b.md": ()})
|
||||
|
||||
def test_rendered_reads_back_whatever_a_path_or_a_name_holds(self) -> None:
|
||||
touches = {"my file.md": (Part("## todo.md: under `Touches:` in its detail"), Part("## ``a`` and `b`", small=True), Part("`"), Part("## ends in `x`"), Part(" x "), Part("lines 2-3")), "a`b.md": (), "c, d: e.md": (Part("# T"),)}
|
||||
self.assertEqual(predicted(f"Touches:\n\n{rendered(touches)}\n"), touches)
|
||||
|
||||
def test_a_bullet_with_an_unclosed_run_a_blank_name_or_a_stray_separator_is_a_failure(self) -> None:
|
||||
for bullet in ("- `a.md`: `` ## A", "- `a.md`: `` ## A `", "- `a.md`: `` ``", "- `a.md`: ", "- `a.md`:", "- `a.md`: `f`, ", "- `a.md`: `f`,`g`", "- ``", "- `a.md` (small)", "- `a.md`: `f` (small) (small)"):
|
||||
with self.subTest(bullet):
|
||||
self.assertIsInstance(predicted(f"Touches:\n\n{bullet}\n"), Failure)
|
||||
|
||||
def test_a_range_that_runs_backwards_is_a_failure_that_says_so(self) -> None:
|
||||
found = predicted("Touches:\n\n- `bin/a.py`: `f`, lines 20-10\n")
|
||||
assert isinstance(found, Failure)
|
||||
self.assertEqual(found.reason, "the bullet '- `bin/a.py`: `f`, lines 20-10' under `Touches:` holds a line range whose first line comes after its last")
|
||||
|
||||
def test_together_joins_items_and_keeps_small_only_where_each_says_so(self) -> None:
|
||||
joined = together([{"a.py": (Part("f", small=True), Part("g", small=True))}, {"a.py": (Part("f"),), "b.md": ()}, {"b.md": (Part("# T"),)}])
|
||||
self.assertEqual(joined, {"a.py": (Part("f"), Part("g", small=True)), "b.md": ()})
|
||||
|
||||
def test_together_keeps_a_part_not_small_once_one_says_so_and_reads_on_past_a_whole_file(self) -> None:
|
||||
joined = together([{"a.py": (Part("f"),), "b.md": ()}, {"b.md": (Part("# T"),), "a.py": (Part("f", small=True),), "c.py": (Part("h"),)}])
|
||||
self.assertEqual(joined, {"a.py": (Part("f"),), "b.md": (), "c.py": (Part("h"),)})
|
||||
|
||||
|
||||
class OverlapsTest(unittest.TestCase):
|
||||
def test_other_files_and_other_parts_do_not_overlap(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("g"),), "b.py": ()}), [])
|
||||
|
||||
def test_the_same_part_overlaps(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("f"), Part("g"))}, {"a.py": (Part("g"),)}), ["`a.py` `g`"])
|
||||
|
||||
def test_a_class_overlaps_its_method_but_not_a_name_it_only_starts(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("Plan"),)}, {"a.py": (Part("Plan.branch"), Part("Planned"))}), ["`a.py` `Plan`"])
|
||||
|
||||
def test_a_whole_file_overlaps_any_part_of_it(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": ()}, {"a.py": (Part("g", small=True),)}), ["`a.py`"])
|
||||
|
||||
def test_reads_on_past_a_file_only_one_touches_and_past_a_whole_file(self) -> None:
|
||||
theirs = {"a.py": (), "b.py": (Part("g"),)}
|
||||
self.assertEqual(overlaps({"z.py": (Part("f"),), "a.py": (), "b.py": (Part("g"),)}, theirs), ["`a.py`", "`b.py` `g`"])
|
||||
|
||||
def test_line_ranges_overlap_where_they_share_a_line(self) -> None:
|
||||
self.assertEqual(overlaps({"x.sh": (Part("lines 1-10"),)}, {"x.sh": (Part("lines 10-12"),)}), ["`x.sh` lines 1-10"])
|
||||
self.assertEqual(overlaps({"x.sh": (Part("lines 1-9"),)}, {"x.sh": (Part("lines 10-12"),)}), [])
|
||||
self.assertEqual(overlaps({"x.sh": (Part("lines 10-12"),)}, {"x.sh": (Part("lines 1-10"),)}), ["`x.sh` lines 10-12"])
|
||||
self.assertEqual(overlaps({"x.sh": (Part("lines 11-12"),)}, {"x.sh": (Part("lines 1-10"),)}), [])
|
||||
|
||||
def test_a_line_range_overlaps_a_named_part_since_nothing_tells_them_apart(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("lines 1-9"),)}, {"a.py": (Part("f"),)}), ["`a.py` lines 1-9"])
|
||||
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("lines 1-9"),)}), ["`a.py` `f`"])
|
||||
|
||||
def test_a_small_change_on_either_side_is_taken(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("f", small=True),)}, {"a.py": (Part("f"),)}), [])
|
||||
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("f", small=True),)}), [])
|
||||
@@ -1,5 +1,7 @@
|
||||
"""An item's prediction of the files and parts it will touch, as its detail spells it, and where two predictions overlap.
|
||||
|
||||
It sits in plan so that plan_store's `FilePlan.check` and todo-item can call `predicted`: touch_predictions imports plan_store, and importing touch_predictions from plan_store would make the two packages import each other.
|
||||
|
||||
The spelling, which the decision `todo.md: an item of the next release predicts the files and parts it will touch …` gives the reasons for:
|
||||
|
||||
Touches:
|
||||
@@ -46,7 +48,7 @@ def predicted(detail: str) -> Touches | None | Failure:
|
||||
break
|
||||
read = bullet(line)
|
||||
if read is None:
|
||||
return Failure(f"the bullet {line!r} under `{LABEL}` is not a path in backticks, then optionally a colon and its parts, each a name in backticks or `lines <first>-<last>`, and optionally `{SMALL}`")
|
||||
return Failure(f"the bullet {line!r} under `{LABEL}` is not a path in backticks, then optionally a colon and its parts, each a name in backticks or `lines <first>-<last>` that `{SMALL.strip()}` may follow; `{SMALL.strip()}` follows a part, never a bare path")
|
||||
if any(span and span[0] > span[1] for span in map(line_range, read[1])):
|
||||
return Failure(f"the bullet {line!r} under `{LABEL}` holds a line range whose first line comes after its last")
|
||||
touches = together([touches, {read[0]: read[1]}])
|
||||
@@ -7,6 +7,7 @@ from plan_store.plans import cells, Plan, Written
|
||||
from failure import Failure
|
||||
from plan.todo_table import item_details, items, NoItemsTable, renames
|
||||
from plan_store import markdown_edits
|
||||
from plan.touches import predicted
|
||||
from plan import ranking
|
||||
from record_store.stores import RecordStore
|
||||
from text_files.file_writes import replace_file
|
||||
@@ -84,7 +85,7 @@ class FilePlan:
|
||||
return ranked
|
||||
|
||||
def check(self) -> list[str]:
|
||||
"""Why `rank_todo.py --check` fails on the file, empty when it passes: the file is not ranked, or an item scores under the bar."""
|
||||
"""Why `rank_todo.py --check` fails on the file, empty when it passes: the file is not ranked, an item scores under the bar, or touch-predictions cannot read an item's `Touches:` list."""
|
||||
texts = self.texts()
|
||||
if isinstance(texts, Failure):
|
||||
return [texts.reason]
|
||||
@@ -92,7 +93,7 @@ class FilePlan:
|
||||
if isinstance(ranked, Failure):
|
||||
return [ranked.reason]
|
||||
unranked = [] if ranked.text == texts[0] else [f"{self.path}: not ranked; run rank_todo.py on it"]
|
||||
return unranked + [f"{self.path}: {line}" for line in ranked.under_bar]
|
||||
return unranked + [f"{self.path}: {line}" for line in ranked.under_bar + unreadable_touches(texts[0])]
|
||||
|
||||
def reported(self, ranked: ranking.Ranked) -> list[str]:
|
||||
"""Ranking's notes and under-bar lines, each prefixed with the file's path, as a tool prints them on stderr."""
|
||||
@@ -115,6 +116,14 @@ class FilePlan:
|
||||
return weighing if isinstance(weighing, Failure) else (plan, *weighing)
|
||||
|
||||
|
||||
def unreadable_touches(todo: str) -> list[str]:
|
||||
"""One line per item whose `Touches:` list touch-predictions cannot read, saying why. Every item is read, not only the next release's: a later item moves into the next release with its detail, and the list is fixed most cheaply where it was written."""
|
||||
details = item_details(todo)
|
||||
if isinstance(details, Failure):
|
||||
return [details.reason]
|
||||
return [f"item {id_}: {read.reason}" for id_, detail in details.items() if isinstance(read := predicted(detail), Failure)]
|
||||
|
||||
|
||||
def plan_of(todo: str) -> Plan | Failure:
|
||||
"""The plan a todo.md's text holds."""
|
||||
found = items(todo)
|
||||
|
||||
+3
-2
@@ -11,7 +11,8 @@ question rows come first, then security rows, then the rest, each group by score
|
||||
then by ID. Then it moves each blocker, an item another's Blocked by cell names, that ranks below
|
||||
an item it blocks to just above the first such item. Orders the details to match. Writes each
|
||||
item's R, and adds the Blocked by and R columns to a table without them. --check doesn't write
|
||||
anything and fails when the file is not ranked as it would be.
|
||||
anything and fails when the file is not ranked as it would be, or when an item's detail holds a
|
||||
`Touches:` list not spelt as `touch-predictions --help` shows.
|
||||
|
||||
A valid todo.md; ## Details and each item's detail are optional:
|
||||
|
||||
@@ -87,7 +88,7 @@ Exit 1, saying why, on bad arguments, a checkout no config names or a config tha
|
||||
file given that is not the config's plan, a file that cannot be read or written, a todo.md, goals file or docs/decisions.md that breaks the
|
||||
rules above, a scoring run on docs/comprehension-history.md's newest scored commit with no Mean row
|
||||
ending in its overall, an item that is not exempt scoring under the bar, or --check finding the file
|
||||
unranked.
|
||||
unranked, or an item's `Touches:` list unreadable.
|
||||
"""
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
@@ -12,6 +12,7 @@ from plan.test_ranking import DECISIONS, OLD_SHAPE, README, TODO
|
||||
from project_config.settings import DEFAULT_FLOOR
|
||||
from plan import goals_file, ranking
|
||||
import rank_todo
|
||||
from todo_item.test_todo_item import READABLE_TOUCHES, UNREADABLE_BULLETS
|
||||
|
||||
|
||||
class Main(unittest.TestCase):
|
||||
@@ -102,6 +103,25 @@ class Main(unittest.TestCase):
|
||||
self.assertEqual(self.run_main(str(todo)), (1, f"{todo}: {under}\n"))
|
||||
self.assertEqual(self.run_main("--check", str(todo)), (1, f"{todo}: {under}\n"))
|
||||
|
||||
def test_check_fails_on_each_item_whose_touches_list_it_cannot_read(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
todo = pathlib.Path(temp, "todo.md")
|
||||
configured(self, pathlib.Path(temp))
|
||||
self.enterContext(contextlib.chdir(temp))
|
||||
pathlib.Path(temp, "README.md").write_text(README)
|
||||
pathlib.Path(temp, "docs").mkdir()
|
||||
pathlib.Path(temp, "docs", "decisions.md").write_text(DECISIONS)
|
||||
for bullet in UNREADABLE_BULLETS:
|
||||
with self.subTest(bullet):
|
||||
# Item 1 sits in a later release than item 3: the check reads every item's list, not only the next release's.
|
||||
todo.write_text(TODO.replace("Fast detail.", READABLE_TOUCHES).replace("Later detail.", f"Touches:\n\n{bullet}"))
|
||||
self.assertEqual(self.run_main(str(todo))[0], 0)
|
||||
code, said = self.run_main("--check", str(todo))
|
||||
self.assertEqual(code, 1)
|
||||
self.assertTrue(said.startswith(f"{todo}: item 1: "), said)
|
||||
self.assertIn(repr(bullet), said)
|
||||
self.assertEqual(said.count("\n"), 1)
|
||||
|
||||
def test_says_to_reshape_an_old_shape_table_but_passes_the_check(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
todo = pathlib.Path(temp, "todo.md")
|
||||
|
||||
+14
-4
@@ -27,7 +27,8 @@ list and show read only the plan, and print no Score: an item's place in list's
|
||||
|
||||
add files the item under the next free ID, with the tagline in bold, and the detail it reads from
|
||||
stdin, if any. The detail may hold no ## or ### heading.
|
||||
It prints `Filed item <ID> in <plan>.` It doesn't write anything where ranking fails or scores the item under the bar.
|
||||
It prints `Filed item <ID> in <plan>.` It doesn't write anything where ranking fails or scores the item under the bar,
|
||||
or where the detail holds a `Touches:` list not spelt as `touch-predictions --help` shows.
|
||||
In a Jira epic, add files a Task under the epic, and <ID> is the new issue's number. The release
|
||||
must be one of the Jira project's Fix Versions, named as 1.2.0 or v1.2.0 there, and --exempt
|
||||
security also labels the issue `security`. The item scores by the config's `jira-score-formula`, and
|
||||
@@ -41,7 +42,8 @@ edit sets the cells whose flag is given and leaves the rest; an empty value, as
|
||||
empties the cell. --detail replaces the detail with the text on stdin, and --clear-detail removes it.
|
||||
Text on stdin without --detail, and --detail without text on stdin, are refused, so no detail is
|
||||
dropped or wiped by mistake. It prints `Edited item <ID> in <plan>.` It doesn't write anything where
|
||||
ranking fails or scores the item under the bar.
|
||||
ranking fails or scores the item under the bar, or where a new detail holds a `Touches:` list not
|
||||
spelt as `touch-predictions --help` shows.
|
||||
In a Jira epic, edit changes an issue the loop filed: its summary, description and scores, the label
|
||||
`security` with --exempt, and its "is blocked by" links with --blocked-by: it makes a link for each
|
||||
blocker added and deletes the link of each blocker dropped. Each blocker must be an open child of the
|
||||
@@ -89,6 +91,7 @@ from project_config.main import located
|
||||
from plan_store.plans import no_item, PlanStore, TAGLINE, Written
|
||||
from plan.release import parsed, Release, version as release_version
|
||||
from plan_store.stores import store as plan_store
|
||||
from plan.touches import predicted
|
||||
from record_store.stores import RecordStore, store
|
||||
from todo_item.table import shown, table
|
||||
from todo_item.edits import with_bullet
|
||||
@@ -115,7 +118,8 @@ def main(argv: list[str], folder: pathlib.Path = pathlib.Path(), stdin: typing.T
|
||||
case "show":
|
||||
done = show(args, plan)
|
||||
case "add":
|
||||
done = reported(plan.add(fields(args), piped(stdin)), "not filed", lambda written: f"Filed item {written.id} in {plan.label}.")
|
||||
detail = piped(stdin)
|
||||
done = unreadable(detail, "not filed") or reported(plan.add(fields(args), detail), "not filed", lambda written: f"Filed item {written.id} in {plan.label}.")
|
||||
case "edit":
|
||||
done = edit(args, plan, piped(stdin))
|
||||
case "move":
|
||||
@@ -194,6 +198,12 @@ def reported(written: Written | Failure, refusal: str, done: typing.Callable[[Wr
|
||||
return done(written)
|
||||
|
||||
|
||||
def unreadable(detail: str | None, refusal: str) -> Failure | None:
|
||||
"""A Failure opened with refusal where detail holds a `Touches:` list touch-predictions cannot read; checked here, before the plan's backend gets the detail, so a plan in Jira is held to it too."""
|
||||
read = None if detail is None else predicted(detail)
|
||||
return Failure(f"{refusal}: {read.reason}") if isinstance(read, Failure) else None
|
||||
|
||||
|
||||
def list_(args: argparse.Namespace, plan: PlanStore) -> str | Failure:
|
||||
read = plan.read()
|
||||
if isinstance(read, Failure):
|
||||
@@ -220,7 +230,7 @@ def edit(args: argparse.Namespace, plan: PlanStore, text: str) -> str | Failure:
|
||||
detail = text if args.detail else "" if args.clear_detail else None
|
||||
if not fields(args) and detail is None:
|
||||
return Failure("not edited: no flag names a change; todo-item --help lists them")
|
||||
return reported(plan.edit(args.id, fields(args), detail, args.comment), "not edited", lambda written: f"Edited item {written.id} in {plan.label}.")
|
||||
return unreadable(detail, f"not edited: item {args.id}'s detail") or reported(plan.edit(args.id, fields(args), detail, args.comment), "not edited", lambda written: f"Edited item {written.id} in {plan.label}.")
|
||||
|
||||
|
||||
def finish(args: argparse.Namespace, plan: PlanStore, changelog: RecordStore | None) -> str | Failure:
|
||||
|
||||
@@ -25,6 +25,16 @@ CHANGELOG = "# Changelog\n\n## Unreleased\n\n- Older news.\n\n## 0.1.0\n\n- Firs
|
||||
# ## Details of the ranked fixture, without the trailing ## Notes.
|
||||
HEADER = "| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves |\n|---|---|---|---|---|---|---|---|---|---|---|\n"
|
||||
DETAILS = "## Details\n\n### 3. Make it fast, `a | b`.\n\nFast detail.\n\n### 1. Ship the later thing.\n\nLater detail.\n\n"
|
||||
# The bullets six items held on 2026-11-18, which touch-predictions cannot read: `(small)` after a bare path, and a part not in backticks.
|
||||
UNREADABLE_BULLETS = (
|
||||
"- `bin/judge_replay/main.py` (small)",
|
||||
"- `bin/do_epic/main.py` (small)",
|
||||
"- `principles/technical-principles.md`: the tests bullet group, `A valuable test checks behaviour` (small)",
|
||||
"- `README.md`: loop-claude's section (small)",
|
||||
"- `bin/rule_hook/rules.py`: the rule table (small)",
|
||||
"- `settings.json`: the PreToolUse matcher (small)",
|
||||
)
|
||||
READABLE_TOUCHES = "Why.\n\nTouches:\n\n- `bin/a.py`: `main`, `Plan.branch` (small)\n- `bin/run.sh`: lines 10-20\n- `docs/new.md`\n"
|
||||
|
||||
|
||||
class Terminal(io.StringIO):
|
||||
@@ -488,6 +498,37 @@ class Edit(TodoItem):
|
||||
self.assertEqual(self.todo.read_text(), before)
|
||||
|
||||
|
||||
class UnreadableTouches(TodoItem):
|
||||
"""A `Touches:` list touch-predictions cannot read is refused when written, since loop-claude doesn't start any chunk beside an item whose list it cannot read."""
|
||||
|
||||
def test_add_and_edit_refuse_each_bullet_that_stalled_the_loop(self):
|
||||
for bullet in UNREADABLE_BULLETS:
|
||||
for argv, refusal in ((ADD, "not filed: "), (["edit", "3", "--detail"], "not edited: item 3's detail: ")):
|
||||
with self.subTest(bullet=bullet, command=argv[0]):
|
||||
before = self.todo.read_text()
|
||||
code, out, err = self.run_main(*argv, stdin=f"Why.\n\nTouches:\n\n- `bin/a.py`: `main`\n{bullet}\n")
|
||||
self.assertEqual((code, out), (1, ""))
|
||||
self.assertTrue(err.startswith(refusal), err)
|
||||
self.assertIn(repr(bullet), err)
|
||||
self.assertEqual(self.todo.read_text(), before)
|
||||
|
||||
def test_add_and_edit_take_a_readable_list_and_a_detail_without_one(self):
|
||||
for detail in (READABLE_TOUCHES, "Why, without a list.\n"):
|
||||
with self.subTest(detail):
|
||||
self.assertEqual(self.run_main(*ADD, stdin=detail)[0], 0)
|
||||
self.assertEqual(self.run_main("edit", "3", "--detail", stdin=detail)[0], 0)
|
||||
self.assertIn(detail, self.todo.read_text())
|
||||
|
||||
def test_a_plan_in_jira_gets_no_unreadable_list_either(self):
|
||||
self.config.write_text(self.config.read_text().replace('"checkout:todo.md"', f'"{JIRA_PLAN}"') + 'env-file = "~/acme.env"\n' + JIRA_SCORING)
|
||||
plan = MemoryPlan({3: {"Release": "0.1.0", "Item": "**Count the runs.**", "L": "1", "E": "2", "I": "3", "S": "1"}})
|
||||
self.enterContext(unittest.mock.patch.object(main, "plan_store", return_value=plan))
|
||||
detail = f"Touches:\n\n{UNREADABLE_BULLETS[0]}\n"
|
||||
self.assertEqual(self.run_main(*ADD, stdin=detail)[:2], (1, ""))
|
||||
self.assertEqual(self.run_main("edit", "3", "--detail", stdin=detail)[:2], (1, ""))
|
||||
self.assertEqual((list(plan.rows), plan.details), ([3], {}))
|
||||
|
||||
|
||||
class Move(TodoItem):
|
||||
def test_sets_the_items_release_and_keeps_the_rest(self):
|
||||
self.assertEqual(self.run_main("move", "3", "--release", "0.2.0"), (0, f"Moved item 3 to release 0.2.0 in {self.todo}.\n", ""))
|
||||
|
||||
@@ -3,7 +3,7 @@ import dataclasses
|
||||
|
||||
from failure import Failure
|
||||
from plan.todo_table import Item, waiting
|
||||
from touch_predictions.prediction import LABEL, overlaps, predicted, Touches
|
||||
from plan.touches import LABEL, overlaps, predicted, Touches
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
|
||||
@@ -3,7 +3,7 @@ import re
|
||||
|
||||
from failure import Failure
|
||||
from git_cli.git_repo import git, Git
|
||||
from touch_predictions.prediction import Part, Touches
|
||||
from plan.touches import Part, Touches
|
||||
from touch_predictions.file_parts import part_names
|
||||
|
||||
HUNK = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@", re.M)
|
||||
|
||||
@@ -49,7 +49,7 @@ import typing
|
||||
from git_cli.git_repo import default_ref, git, Git
|
||||
from failure import Failure
|
||||
from plan_store.stores import store as plan_store
|
||||
from touch_predictions.prediction import predicted, together, Touches
|
||||
from plan.touches import predicted, together, Touches
|
||||
from project_config.main import project
|
||||
from project_config.settings import ProjectConfig, TOUCH_PREDICTIONS
|
||||
from touch_predictions import record
|
||||
|
||||
@@ -3,7 +3,7 @@ import re
|
||||
|
||||
from failure import Failure
|
||||
from record_store.stores import RecordStore
|
||||
from touch_predictions.prediction import rendered, Touches
|
||||
from plan.touches import rendered, Touches
|
||||
from text_files.utc_stamp import STAMPED
|
||||
|
||||
TITLE = "# Touch predictions"
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
import os
|
||||
import pathlib
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
@@ -10,53 +9,16 @@ import unittest
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from touch_predictions.beside import Beside, chunks_beside
|
||||
from adf_codec import convert
|
||||
from touch_predictions import diff_parts, file_parts, main, record
|
||||
from failure import Failure
|
||||
from test_env import isolated_env
|
||||
from project_config.main import located
|
||||
from record_store.fakes import MemoryStore
|
||||
from touch_predictions.prediction import overlaps, Part, predicted, rendered, together
|
||||
from plan.touches import Part
|
||||
from plan_store.todo_md import plan_of
|
||||
from project_config.settings import ProjectConfig
|
||||
from project_config.test_project_config import write_config
|
||||
|
||||
DETAIL = """A planning call.
|
||||
|
||||
Touches:
|
||||
|
||||
- `bin/a.py`: `main`, `Plan.branch` (small)
|
||||
- `README.md`: `## Goals, and (more): things`
|
||||
- `bin/run.sh`: lines 10-20
|
||||
- `docs/new.md`
|
||||
|
||||
More prose, with `bin/b.py` named.
|
||||
"""
|
||||
|
||||
needs_docker = unittest.skipIf(shutil.which("docker") is None or subprocess.run(["docker", "info"], capture_output=True, timeout=20).returncode != 0, "adf_codec runs in a container, which needs a docker daemon")
|
||||
|
||||
|
||||
def text(words: str, code: bool = False) -> dict:
|
||||
return {"type": "text", "text": words, **({"marks": [{"type": "code"}]} if code else {})}
|
||||
|
||||
|
||||
def bullet_of(*spans: dict) -> dict:
|
||||
return {"type": "listItem", "attrs": {"localId": "i"}, "content": [{"type": "paragraph", "attrs": {"localId": "p"}, "content": list(spans)}]}
|
||||
|
||||
|
||||
# A Touches list as someone types it in Jira's editor: a paragraph, then a bulleted list whose paths and names carry the code mark.
|
||||
JIRA_TOUCHES = {"type": "doc", "version": 1, "content": [
|
||||
{"type": "paragraph", "attrs": {"localId": "a"}, "content": [text("A planning call.")]},
|
||||
{"type": "paragraph", "attrs": {"localId": "b"}, "content": [text("Touches:")]},
|
||||
{"type": "bulletList", "attrs": {"localId": "c"}, "content": [
|
||||
bullet_of(text("bin/a.py", True), text(": "), text("main", True), text(", "), text("Plan.branch", True), text(" (small)")),
|
||||
bullet_of(text("a`b.md", True), text(": "), text("## The `foo` tool", True), text(" (small)"), text(", "), text("`x`", True)),
|
||||
bullet_of(text("bin/run.sh", True), text(": lines 10-20")),
|
||||
bullet_of(text("docs/new.md", True)),
|
||||
]},
|
||||
{"type": "paragraph", "attrs": {"localId": "d"}, "content": [text("More prose.")]},
|
||||
]}
|
||||
|
||||
PYTHON = """\"\"\"Docstring.\"\"\"
|
||||
import os
|
||||
|
||||
@@ -98,126 +60,6 @@ Text.
|
||||
"""
|
||||
|
||||
|
||||
class PredictedTest(unittest.TestCase):
|
||||
def test_reads_each_bullet_of_the_touches_list(self) -> None:
|
||||
self.assertEqual(predicted(DETAIL), {
|
||||
"bin/a.py": (Part("main"), Part("Plan.branch", small=True)),
|
||||
"README.md": (Part("## Goals, and (more): things"),),
|
||||
"bin/run.sh": (Part("lines 10-20"),),
|
||||
"docs/new.md": (),
|
||||
})
|
||||
|
||||
def test_a_detail_without_the_list_predicts_nothing(self) -> None:
|
||||
self.assertIsNone(predicted("Only prose, with `bin/a.py` named."))
|
||||
|
||||
def test_a_bullet_it_cannot_read_is_a_failure_that_quotes_it(self) -> None:
|
||||
for bullet in ("- bin/a.py: main", "- `bin/a.py`: main", "- `bin/a.py`: lines 20-10", "- `bin/a.py`: `main` `other`"):
|
||||
with self.subTest(bullet):
|
||||
found = predicted(f"Touches:\n\n{bullet}\n")
|
||||
assert isinstance(found, Failure)
|
||||
self.assertIn(bullet, found.reason)
|
||||
|
||||
def test_an_empty_list_is_a_failure(self) -> None:
|
||||
self.assertIsInstance(predicted("Touches:\n\nProse.\n"), Failure)
|
||||
found = predicted("Touches:\n")
|
||||
assert isinstance(found, Failure)
|
||||
self.assertEqual(found.reason, "no bullet follows `Touches:`")
|
||||
|
||||
def test_reads_a_list_right_under_its_label_a_one_line_range_and_a_name_of_any_letters(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `a.py`: `Xray`, lines 5-5\n"), {"a.py": (Part("Xray"), Part("lines 5-5"))})
|
||||
|
||||
def test_rendered_reads_back(self) -> None:
|
||||
touches = predicted(DETAIL)
|
||||
assert isinstance(touches, dict)
|
||||
self.assertEqual(predicted(f"Touches:\n\n{rendered(touches)}\n"), touches)
|
||||
|
||||
def test_a_name_that_holds_backticks_takes_a_longer_run_with_a_space_inside_each_end(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `a.md`: `` ## The `foo` tool `` (small), ``` `` ```, `` `x` ``\n"), {"a.md": (Part("## The `foo` tool", small=True), Part("``"), Part("`x`"))})
|
||||
self.assertEqual(rendered({"a.md": (Part("## The `foo` tool", small=True), Part("``"))}), "- `a.md`: `` ## The `foo` tool `` (small), ``` `` ```")
|
||||
|
||||
def test_a_longer_run_without_padding_spaces_is_the_text_between_its_runs(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- ``a`b.md``: ``## The `foo` tool`` (small), ``` `` ```, `` `x` ``\n"), {"a`b.md": (Part("## The `foo` tool", small=True), Part("``"), Part("`x`"))})
|
||||
|
||||
def test_a_longer_run_with_a_space_at_one_end_only_keeps_it(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `a.md`: `` x``, ``y ``, `` a ``\n"), {"a.md": (Part(" x"), Part("y "), Part("a"))})
|
||||
|
||||
@needs_docker
|
||||
def test_a_list_written_in_markdown_and_read_back_from_a_jira_description_reads_as_written(self) -> None:
|
||||
description = convert.markdown_to_adf(DETAIL)
|
||||
assert isinstance(description, dict)
|
||||
self.assertEqual(predicted(convert.adf_to_markdown(description)), predicted(DETAIL))
|
||||
|
||||
@needs_docker
|
||||
def test_a_list_typed_in_jiras_editor_reads_as_its_files_and_parts(self) -> None:
|
||||
read = convert.adf_to_markdown(JIRA_TOUCHES)
|
||||
self.assertEqual(predicted(read), {
|
||||
"bin/a.py": (Part("main"), Part("Plan.branch", small=True)),
|
||||
"a`b.md": (Part("## The `foo` tool", small=True), Part("`x`")),
|
||||
"bin/run.sh": (Part("lines 10-20"),),
|
||||
"docs/new.md": (),
|
||||
})
|
||||
|
||||
def test_a_name_ends_only_at_a_run_as_long_as_the_one_that_opens_it(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `a.md`: `` a ``` b ``, `c``d`\n"), {"a.md": (Part("a ``` b"), Part("c``d"))})
|
||||
|
||||
def test_a_path_holds_any_character_and_a_single_backtick_keeps_a_names_spaces(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `my file.md`: ` x `\n- `` a`b.md ``\n"), {"my file.md": (Part(" x "),), "a`b.md": ()})
|
||||
|
||||
def test_rendered_reads_back_whatever_a_path_or_a_name_holds(self) -> None:
|
||||
touches = {"my file.md": (Part("## todo.md: under `Touches:` in its detail"), Part("## ``a`` and `b`", small=True), Part("`"), Part("## ends in `x`"), Part(" x "), Part("lines 2-3")), "a`b.md": (), "c, d: e.md": (Part("# T"),)}
|
||||
self.assertEqual(predicted(f"Touches:\n\n{rendered(touches)}\n"), touches)
|
||||
|
||||
def test_a_bullet_with_an_unclosed_run_a_blank_name_or_a_stray_separator_is_a_failure(self) -> None:
|
||||
for bullet in ("- `a.md`: `` ## A", "- `a.md`: `` ## A `", "- `a.md`: `` ``", "- `a.md`: ", "- `a.md`:", "- `a.md`: `f`, ", "- `a.md`: `f`,`g`", "- ``", "- `a.md` (small)", "- `a.md`: `f` (small) (small)"):
|
||||
with self.subTest(bullet):
|
||||
self.assertIsInstance(predicted(f"Touches:\n\n{bullet}\n"), Failure)
|
||||
|
||||
def test_a_range_that_runs_backwards_is_a_failure_that_says_so(self) -> None:
|
||||
found = predicted("Touches:\n\n- `bin/a.py`: `f`, lines 20-10\n")
|
||||
assert isinstance(found, Failure)
|
||||
self.assertEqual(found.reason, "the bullet '- `bin/a.py`: `f`, lines 20-10' under `Touches:` holds a line range whose first line comes after its last")
|
||||
|
||||
def test_together_joins_items_and_keeps_small_only_where_each_says_so(self) -> None:
|
||||
joined = together([{"a.py": (Part("f", small=True), Part("g", small=True))}, {"a.py": (Part("f"),), "b.md": ()}, {"b.md": (Part("# T"),)}])
|
||||
self.assertEqual(joined, {"a.py": (Part("f"), Part("g", small=True)), "b.md": ()})
|
||||
|
||||
def test_together_keeps_a_part_not_small_once_one_says_so_and_reads_on_past_a_whole_file(self) -> None:
|
||||
joined = together([{"a.py": (Part("f"),), "b.md": ()}, {"b.md": (Part("# T"),), "a.py": (Part("f", small=True),), "c.py": (Part("h"),)}])
|
||||
self.assertEqual(joined, {"a.py": (Part("f"),), "b.md": (), "c.py": (Part("h"),)})
|
||||
|
||||
|
||||
class OverlapsTest(unittest.TestCase):
|
||||
def test_other_files_and_other_parts_do_not_overlap(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("g"),), "b.py": ()}), [])
|
||||
|
||||
def test_the_same_part_overlaps(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("f"), Part("g"))}, {"a.py": (Part("g"),)}), ["`a.py` `g`"])
|
||||
|
||||
def test_a_class_overlaps_its_method_but_not_a_name_it_only_starts(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("Plan"),)}, {"a.py": (Part("Plan.branch"), Part("Planned"))}), ["`a.py` `Plan`"])
|
||||
|
||||
def test_a_whole_file_overlaps_any_part_of_it(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": ()}, {"a.py": (Part("g", small=True),)}), ["`a.py`"])
|
||||
|
||||
def test_reads_on_past_a_file_only_one_touches_and_past_a_whole_file(self) -> None:
|
||||
theirs = {"a.py": (), "b.py": (Part("g"),)}
|
||||
self.assertEqual(overlaps({"z.py": (Part("f"),), "a.py": (), "b.py": (Part("g"),)}, theirs), ["`a.py`", "`b.py` `g`"])
|
||||
|
||||
def test_line_ranges_overlap_where_they_share_a_line(self) -> None:
|
||||
self.assertEqual(overlaps({"x.sh": (Part("lines 1-10"),)}, {"x.sh": (Part("lines 10-12"),)}), ["`x.sh` lines 1-10"])
|
||||
self.assertEqual(overlaps({"x.sh": (Part("lines 1-9"),)}, {"x.sh": (Part("lines 10-12"),)}), [])
|
||||
self.assertEqual(overlaps({"x.sh": (Part("lines 10-12"),)}, {"x.sh": (Part("lines 1-10"),)}), ["`x.sh` lines 10-12"])
|
||||
self.assertEqual(overlaps({"x.sh": (Part("lines 11-12"),)}, {"x.sh": (Part("lines 1-10"),)}), [])
|
||||
|
||||
def test_a_line_range_overlaps_a_named_part_since_nothing_tells_them_apart(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("lines 1-9"),)}, {"a.py": (Part("f"),)}), ["`a.py` lines 1-9"])
|
||||
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("lines 1-9"),)}), ["`a.py` `f`"])
|
||||
|
||||
def test_a_small_change_on_either_side_is_taken(self) -> None:
|
||||
self.assertEqual(overlaps({"a.py": (Part("f", small=True),)}, {"a.py": (Part("f"),)}), [])
|
||||
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("f", small=True),)}), [])
|
||||
|
||||
|
||||
class FilePartsTest(unittest.TestCase):
|
||||
def names(self, path: str, text: str, *lines: int) -> set[str] | None:
|
||||
return file_parts.part_names(path, text, lines)
|
||||
|
||||
+3
-1
@@ -686,6 +686,8 @@ A project's rung is its model's cheapest rung, which for Opus 5.5 is its default
|
||||
|
||||
2026-11-15, lilleman asked for the ladder as a file that a project can replace, on a day when an outage left only Fable 5.2 answering: the rungs were a constant in `bin/model_routing/ladder.py`, so no project could leave Sonnet 5.5 and Opus 5.5 without a release. The shipped ladder is `bin/model_routing/routing-ladder.json`, a JSON list of rungs, least competent first. A project that keeps a `routing-ladder.json` in its config's folder, `~/.claude-projects/<key>/`, runs on that ladder whole, and the steps count on it as on the shipped one. Every project still runs the same routing rules and steps, so the workflow of goal 1.3 holds; the ladder joins what a project's config folder may supply, which that goal's list does not name yet. lilleman chose a file per project over one per machine, so a single project can differ. A ladder holds one model of each family, since the Agent tool launches a subagent or a review by its family's name. The project's file is lilleman's to write, as any change to the ladder is, and the loop never commits it. loop-claude reads the project's ladder as each cycle starts; `subagent-rung` and rule-hook's `reviewer-rung` read it each time they run, from the checkout they run in. A ladder file that holds a fault stops each of them, since work routed on the shipped ladder in its place could run on a model the project cannot reach. The routing figures, `judge-replay` and `review-replay` span every project, so they read the shipped ladder: a rung only a project's own ladder holds is left out of the figures' calls, and no replay qualifies it. lilleman shipped the change as 0.10.1, a patch cut from the tag v0.10.0, on the day of the outage: it adds a file format and an exit 1 to `subagent-rung`, which the technical principles' semantic versioning gives a minor, and lilleman asked for the patch "even if that breaks semver", so that the release in use could run again without taking the unreleased work on `main`.
|
||||
|
||||
2026-11-18, lilleman kept the ladder and the steps, settling the call raised on the routing figures measured at 2026-11-18T15:04:48Z: chunks routed onto Sonnet 5.5 at high took more review rounds past each pass's first than chunks routed onto Opus 5.5 at medium. The figures came from 19 chunks finished since the 2026-11-17 reset. The 13 chunks started on Sonnet 5.5 at high took a mean 0.5 rounds and 0.0 unfinished verdicts; the 6 started on Opus 5.5 at medium took 0.5 and 0.2. Neither rung had later fixes, among the 11 and the 4 chunks whose later fixes are known. Both means show 0.5, so the gap is under 0.1 rounds. Sonnet 5.5 did better on unfinished verdicts, and it is the cheaper rung (goal 1.4). loop-claude lists the call in `routing-calls-raised.md` only once the session that put it to lilleman ends, stamped with the time the figures were measured, so this note cites that time.
|
||||
|
||||
Valid while the index ranks these models, and while no newer model joins the catalog.
|
||||
|
||||
## routing: the offline classifier may decide finished, since lilleman ruled a miss rate of about 1 in 100 decided close enough to none; the judge's model keeps every other verdict kind
|
||||
@@ -804,7 +806,7 @@ Valid while the worker writes the tests that larv-review's reviewers hold to the
|
||||
|
||||
## todo.md: an item of the next release predicts the files and parts it will touch under `Touches:` in its detail; chunk-preflight takes, in the plan's order, the items that overlap none taken before them as the chunks that may run at once, and the optional `touch-predictions` record keeps each chunk's prediction beside what it touched
|
||||
|
||||
2026-11-15, lilleman's call of 2026-11-13 in item 373, which split item 361. Serves goal 1.5, held to goal 1.4: several chunks of one project run at once only where they are unlikely to touch the same lines, since a conflict costs a rebase, a gate rerun and often a review round. A session on the project's rung or above writes each prediction, as `rules/todo-items.md` says, and `bin/touch_predictions/` reads it. The choices the call left open:
|
||||
2026-11-15, lilleman's call of 2026-11-13 in item 373, which split item 361. Serves goal 1.5, held to goal 1.4: several chunks of one project run at once only where they are unlikely to touch the same lines, since a conflict costs a rebase, a gate rerun and often a review round. A session on the project's rung or above writes each prediction, as `rules/todo-items.md` says, and `bin/plan/touches.py` reads it. The choices the call left open:
|
||||
|
||||
- **The spelling.** A `Touches:` line, then one bullet per file: the path in backticks, then its parts, each a name in backticks or `lines <first>-<last>`, with `(small)` after a part the item changes only a little; a path or a name that holds a backtick takes a longer run of backticks with a space inside each end, as a Markdown code span does. A path alone is the whole file. Three readers seated as the README's audience picked the bulleted list over one line and over a table, since backticks hold a heading's commas, colons and parentheses. Two of the three put `(small)` after the part and outside the backticks, and two left line ranges unquoted. Each picked a different config key: `touch-predictions` was one reader's first choice and the second choice of the other two.
|
||||
- **A part's boundaries.** Python's `ast` module names the innermost function or class, a top-level assignment by the name it sets, and `(module)` for the rest. A Markdown file's parts are its headings outside fenced code. Any other file, and Python that doesn't parse, falls back to line ranges. A table row is no part of its own: the item named one, but the tables chunks collide on are the plan's and the changelog's, which don't count.
|
||||
|
||||
+1
-1
@@ -30,4 +30,4 @@ paths:
|
||||
- **The Exempt cell keeps an item whatever its score:** `security` for a security finding, `defect` for a 🔴 finding or an item that restores a maintain goal the project breaks today, `question` for a question only the human can answer, which ranks first in its release, `decision` for an item `docs/decisions.md` cites, `owner` for an item the human told you to keep, and, where no other reason fits, `principle` for a 🟡 finding against a file in the config's principles folder, whose item's detail names that principle. Every item `docs/decisions.md` cites carries one of these reasons.
|
||||
- **A maintain goal vetoes an item that breaks it,** whatever the item scores: redesign the item so it holds the goal, or drop it.
|
||||
- **When you remove an item that no chunk built, title the commit `Drop item <ID>: <why>`,** or `Drop items 12, 14 and 15: <why>` for several. Such an item was deleted under the bar, vetoed, superseded or moot; a finished item is not one. Without the title, `score-outcomes` credits the item with the work of the chunk that removed it, where that chunk changed more than `todo.md`.
|
||||
- **Predict, in the detail of each item of the next release, what the item will touch.** When you plan the next release, or file or move an item into it, give the item's detail a `Touches:` line, then one bullet per file the item will change. Each bullet names the file, then the parts of it the item will change: a function, a class or a section heading, or line ranges where the file has none of these. A path alone means the whole file. Read the code first; a prediction from the item's text alone misses. `~/.claude/bin/touch-predictions --help` shows the spelling and how a part is named; a name that holds a backtick takes a longer run of backticks with a space inside each end, as a Markdown code span does. Mark a part `(small)` where the item changes only a few lines of it. Leave out the plan and the project's records, which every chunk writes. `chunk-preflight` reads the predictions to name the items that may start chunks at once, and `touch-predictions record` keeps each beside what its chunk touched.
|
||||
- **Predict, in the detail of each item of the next release, what the item will touch.** When you plan the next release, or file or move an item into it, give the item's detail a `Touches:` line, then one bullet per file the item will change. Each bullet names the file, then the parts of it the item will change: a function, a class or a section heading, or line ranges where the file has none of these. A path alone means the whole file. Read the code first; a prediction from the item's text alone misses. `~/.claude/bin/touch-predictions --help` shows the spelling and how a part is named; a name that holds a backtick takes a longer run of backticks with a space inside each end, as a Markdown code span does. Mark a part `(small)` where the item changes only a few lines of it. `(small)` follows a part, never a bare path. A part is a name in backticks, or `lines <first>-<last>`. BANNED: ``- `bin/a.py` (small)``, ``- `README.md`: loop-claude's section (small)``. GOOD: ``- `bin/a.py`: `main` (small)``, ``- `README.md`: `## Tools` (small)``. Leave out the plan and the project's records, which every chunk writes. `chunk-preflight` reads the predictions to name the items that may start chunks at once, and `touch-predictions record` keeps each beside what its chunk touched. `todo-item add`, `todo-item edit` and `rank_todo.py --check` refuse a list touch-predictions cannot read.
|
||||
|
||||
@@ -41,6 +41,7 @@
|
||||
| 341 | 0.13.0 | | | **Hand each worker's claude a lower Read limit through `CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS`, kept only where replays of the archived review rounds find what two unchanged replays find.** | 2 | 2 | 3 | 5 | 3 | 1.4 by 3 | 1.0 |
|
||||
| 298 | 0.13.0 | | | **Send the judge only the decision entries and the transcript tail a verdict needs, and keep the cut only where `judge-replay` changes no verdict kind.** | 3 | 3 | 3 | 7 | 4 | 1.4 by 2, 1.5 by 1 | 0.9 |
|
||||
| 395 | 0.13.0 | | decision | **Keep each block a save didn't change, with its localId, and the spacing paragraphs beside it as Jira or Confluence holds them.** | 3 | 2 | 2 | 5 | 5 | 1.6 by 4 | 0.8 |
|
||||
| 425 | 0.13.0 | | | **Show on loop-claude's terminal why it doesn't start a chunk beside the next item, as chunk-preflight prints it.** | 1 | 1 | 2 | 2 | 2 | 1.5 by 2 | 0.7 |
|
||||
| 367 | 0.13.0 | | | **Check that every write to a Jira plan leaves it ranked, as rule-hook's `todo-rank-check` checks `todo.md` today.** | 2 | 2 | 3 | 5 | 3 | 1.6 by 2 | 0.7 |
|
||||
| 423 | 0.13.0 | | | **Skip the judge's model call on a worker's final message that the offline classifier decides is finished.** | 3 | 3 | 3 | 7 | 5 | 1.4 by 2 | 0.4 |
|
||||
| 77 | 0.14.0 | | | **Teach `bin/metric-bench` Go and TypeScript, rerun it once two projects' comprehension histories name places, and bring into review only a metric that tracks the panel.** | 4 | 2 | 1 | 5 | 6 | 1.1 by 7, 1.4 by 7 | 2.1 |
|
||||
@@ -434,6 +435,10 @@ Touches:
|
||||
|
||||
Today a Jira detail edited in one line, or a Confluence record with one entry appended, is written back whole by adf-codec's portable pair, which drops each block's localId and the empty paragraphs Jira uses for spacing. A save whose text is the text a read showed already sends nothing (`docs/decisions.md` → `project config: the loop shows a Jira description and a Confluence page as adf-codec's portable markdown, …`). Match the saved markdown's top-level blocks against the held document's, each as the portable pair reads it, and send the held block where they match. The decision's limit on partial saves ends with this item.
|
||||
|
||||
### 425. Show on loop-claude's terminal why it doesn't start a chunk beside the next item, as chunk-preflight prints it.
|
||||
|
||||
`chunks_beside` names each item it refuses and why, such as an unreadable `Touches:` list, and chunk-preflight prints those lines, but loop-claude's `chunk_windows.may_start` keeps only `picked` and drops them, so idle slots show no reason. Found by item 424's product-owner review; a list a person edits in Jira's UI, or one filed before item 424, still reaches loop-claude unchecked.
|
||||
|
||||
### 367. Check that every write to a Jira plan leaves it ranked, as rule-hook's `todo-rank-check` checks `todo.md` today.
|
||||
|
||||
One of 0.13.0's history ports, per lilleman's call of 2026-11-12.
|
||||
|
||||
Reference in New Issue
Block a user