469 lines
27 KiB
Python
469 lines
27 KiB
Python
"""The do-epic command (docs/decisions.md → `do-epic: drives one Jira epic …`).
|
|
|
|
`do-epic <EPIC-KEY>` starts each of the epic's chunks that may start now, each in a window of the epic's tmux session, as `scheduler` picks them, and puts that session on the terminal. Each window runs `do-epic --chunk <ISSUE-KEY> <EPIC-KEY>`: the cycles of one issue's chunk, run by the code that runs loop-claude's (`agent_cycle`), until the judge rules it finished. Then it starts the chunks that may start now, and its window closes. The window of a human's task runs no cycle: it waits until the task no longer holds up an issue (`human_tasks`), then does the same.
|
|
|
|
After each cycle of a chunk in a repo, the window reads what the chunk's pull request waits on (`gates`). While that is a gate only time or a person passes, the chunk is parked (`parked`): the window frees its running slot and polls the forge, and the chunk's next cycle starts once the worker has something to do and a slot is free. `do-epic <EPIC-KEY> --status` prints what each open issue does."""
|
|
import dataclasses
|
|
import pathlib
|
|
import sys
|
|
import typing
|
|
|
|
from loop_claude.loop.chunk_start import archived_route, routed
|
|
from do_epic import chunk_prompt, findings, finish, gates, human_tasks, parked, scheduler, split, status
|
|
from do_epic.repo_pick import ClaudeWork, HumanTask, recorded, Repo
|
|
from loop_claude.loop.close import closed_cycle
|
|
from project_config.main import located as config_located
|
|
from loop_claude.project.records import CONSEQUENCE, read_records
|
|
from agent_cycle.run import Cycle, run_cycle
|
|
from do_epic.config import DoEpicConfig, load
|
|
from loop_effects.effects import Effects, say
|
|
from project_config.settings import Epic
|
|
from record_store.jira_description import EpicDescription
|
|
from do_epic.backend.protocol import EpicIssue, EpicStore
|
|
from do_epic.epic_record import EpicRecord
|
|
from failure import Failure
|
|
from agent_cycle.verdicts import Finished, TakenIn
|
|
from loop_claude.project.model_choice import get_or_ask_models, Models
|
|
from plan_store.jira_epic import ISSUE_KEY
|
|
from do_epic.backend.jira import JiraEpic
|
|
from agent_cycle.routing import judge_rung
|
|
from do_epic.repos import locate
|
|
from loop_claude.loop.this_loop import Loop
|
|
from loop_claude.loop.reload import LoopRun
|
|
from loop_state.paths import Paths
|
|
from transcript_archive.project_key import project_key
|
|
from model_routing.ladder_file import project_ladder_file, read_ladder, SHIPPED
|
|
from loop_claude.project.premises import read_premises
|
|
from forge.commands import Run, runner
|
|
from claude_code.session import session_named
|
|
from loop_claude.loop.main import setup_version
|
|
from agent_cycle.stop import Stop
|
|
from agent_cycle.direct_message import tell
|
|
from agent_cycle import tmux
|
|
|
|
HELP = f"""usage: do-epic <EPIC-KEY> [--status]
|
|
{findings.USAGE}
|
|
{finish.USAGE}
|
|
|
|
Runs the chunks of one Jira epic, such as ABC-12, each in its own window of the tmux session epic-<EPIC-KEY>.
|
|
An open issue of the epic runs as a chunk once it has a label and no issue blocks it.
|
|
The label names the issue's repo, or says the work changes no repo.
|
|
A `do-epic-human` issue that blocks another gets a window too. The window DMs you once, then waits without taking a place until you close the issue in Jira.
|
|
As many run at once as the epic's description allows with a line such as `**Max parallel chunks:** 2`, one where it has none.
|
|
A repo takes as many chunks as its `parallel-chunks`, and none while loop-claude runs chunks in it.
|
|
A chunk whose worker ends its run while its pull request waits on its checks, an approval or a new review
|
|
is parked: it frees its place for the next chunk, and its window's name says what it awaits. Its worker goes
|
|
on once the checks pass, the approval comes or a reviewer comments, and a place is free; until one is, the
|
|
name says `awaits a slot`. A parked chunk survives a reboot: run do-epic <EPIC-KEY> again to go on polling.
|
|
--status doesn't start any chunk. It prints a line per open issue: that its chunk runs or asks you a question, or why it waits, such as the gate a parked chunk awaits and since when.
|
|
{findings.HELP}
|
|
{finish.HELP}
|
|
The Jira site and its credentials are set in ~/.claude-projects/do-epic/config.toml."""
|
|
# Under the home folder, where a chunk's cycles are archived, a folder per epic. It is not loop-claude's archive, since that archive's readers, such as judge-replay and the routing figures, read loop-claude's prompts.
|
|
ARCHIVE = ".claude/do-epic-transcripts"
|
|
# The flag that prints what each open issue does.
|
|
STATUS_FLAG = "--status"
|
|
# How often a parked chunk reads its pull request's gate, and a human task's window reads the epic: a person answers in hours, and each read is a few calls.
|
|
POLL_SECONDS = 60
|
|
|
|
# The store of an epic's issues and its record, for the epic with this key.
|
|
Backend = typing.Callable[[DoEpicConfig, str], tuple[EpicStore, EpicRecord]]
|
|
|
|
|
|
def jira_backend(config: DoEpicConfig, key: str) -> tuple[EpicStore, EpicRecord]:
|
|
epic = Epic(config.jira_url, key)
|
|
return JiraEpic(epic, config.env_file, finish=config.finish), EpicRecord(EpicDescription(epic, config.env_file))
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True)
|
|
class EpicRun:
|
|
"""What stays the same through one run of do-epic on an epic."""
|
|
key: str
|
|
config: DoEpicConfig
|
|
store: EpicStore
|
|
record: EpicRecord
|
|
paths: Paths
|
|
env: typing.Mapping[str, str]
|
|
launcher: pathlib.Path
|
|
effects: Effects
|
|
# The runner of git's and the forge's commands in a folder.
|
|
forge_at: typing.Callable[[str], Run] = runner
|
|
|
|
@property
|
|
def session(self) -> str:
|
|
return tmux.session_name(tmux.EPIC, self.key)
|
|
|
|
|
|
def main(argv: list[str], env: typing.Mapping[str, str], paths: Paths, launcher: pathlib.Path, effects: Effects, backend: Backend = jira_backend, stdin: typing.TextIO = sys.stdin, forge_at: typing.Callable[[str], Run] = runner) -> int:
|
|
try:
|
|
stop = run(argv, env, paths, launcher, effects, backend, stdin, forge_at)
|
|
except KeyboardInterrupt:
|
|
stop = Stop(130, "")
|
|
except Exception as crash:
|
|
tell(f"do-epic {' '.join(argv)} crashed: {crash!r}", effects)
|
|
raise
|
|
if stop.reason:
|
|
say(stop.reason, effects, stdout=not stop.code)
|
|
# A chunk's stop is DMed, as loop-claude's is, so a chunk left overnight never ends unseen.
|
|
if stop.reason and argv[:1] == [scheduler.CHUNK_FLAG]:
|
|
tell(f"do-epic {' '.join(argv)} stopped: {stop.reason}", effects)
|
|
return stop.code
|
|
|
|
|
|
def run(argv: list[str], env: typing.Mapping[str, str], paths: Paths, launcher: pathlib.Path, effects: Effects, backend: Backend, stdin: typing.TextIO, forge_at: typing.Callable[[str], Run]) -> Stop:
|
|
chunk, words = (argv[1], argv[2:]) if len(argv) >= 2 and argv[0] == scheduler.CHUNK_FLAG else (None, argv)
|
|
status_asked = chunk is None and words[1:] == [STATUS_FLAG]
|
|
words = words[:1] if status_asked else words
|
|
# What the words after the epic's key write into the epic, where they are a filing or a decision.
|
|
writes = findings.parsed(words[1:]) if chunk is None else None
|
|
closes = chunk is None and words[1:] == [finish.CLOSE]
|
|
if (len(words) != 1 and not writes and not closes) or not ISSUE_KEY.fullmatch(words[0]) or (chunk is not None and not ISSUE_KEY.fullmatch(chunk)):
|
|
return Stop(0 if words in (["-h"], ["--help"]) else 1, HELP)
|
|
if writes or closes:
|
|
return epic_written(words[0], writes, paths, backend, stdin)
|
|
# Before anything starts: a clone, a claude session or a tmux window.
|
|
if reason := tmux.unusable(effects.tmux, chunk_prompt.DRIVER):
|
|
return Stop(1, reason)
|
|
config = load(paths.home)
|
|
if isinstance(config, Failure):
|
|
return Stop(1, config.reason)
|
|
store, record = backend(config, words[0])
|
|
epic = EpicRun(words[0], config, store, record, paths, env, launcher, effects, forge_at)
|
|
if status_asked:
|
|
return status_printed(epic)
|
|
return windows_opened(epic) if chunk is None else chunk_run(chunk, epic)
|
|
|
|
|
|
def status_printed(epic: EpicRun) -> Stop:
|
|
"""What `do-epic <EPIC-KEY> --status` does: prints a line per open issue, and doesn't start anything."""
|
|
issues = epic.store.read()
|
|
lines = issues if isinstance(issues, Failure) else status.lines(epic.key, epic.paths.home, issues, epic.effects.tmux)
|
|
return Stop(1, lines.reason) if isinstance(lines, Failure) else Stop(0, "\n".join(lines) or f"the epic {epic.key} has no open issue")
|
|
|
|
|
|
def epic_written(key: str, writes: tuple[str, str, tuple[str, ...]] | None, paths: Paths, backend: Backend, stdin: typing.TextIO) -> Stop:
|
|
"""Files a finding in the epic or records a decision in its description, as writes says; closes the epic where writes is None. It needs no tmux, so a chunk's worker may run it anywhere."""
|
|
config = load(paths.home)
|
|
if isinstance(config, Failure):
|
|
return Stop(1, config.reason)
|
|
store, record = backend(config, key)
|
|
done = findings.written(key, *writes, store, record, stdin, paths.home / scheduler.STATE / key) if writes else finish.closed(key, store, stdin)
|
|
return Stop(1, done.reason) if isinstance(done, Failure) else Stop(0, done)
|
|
|
|
|
|
def windows_opened(epic: EpicRun) -> Stop:
|
|
"""What the do-epic the human runs does: starts each chunk that may start now, says why each other open issue waits, then puts the epic's session on the terminal until the human detaches."""
|
|
issues = epic.store.read()
|
|
started = issues if isinstance(issues, Failure) else chunks_started(epic, issues, None)
|
|
if isinstance(started, Failure):
|
|
return Stop(1, started.reason)
|
|
say(f"started {', '.join(started.started)} in the tmux session {epic.session}" if started.started else "started no chunk", epic.effects, stdout=True)
|
|
for wait in started.waits:
|
|
say(f"{wait.issue} waits: {wait.reason}", epic.effects, stdout=True)
|
|
if started.closed:
|
|
say(f"the epic {epic.key} is closed", epic.effects, stdout=True)
|
|
if not tmux.listed(epic.session, epic.effects.tmux):
|
|
return Stop(0, "")
|
|
if not epic.effects.on_terminal():
|
|
say(f"not on a terminal; see the chunks with `tmux attach -t ={epic.session}`", epic.effects, stdout=True)
|
|
return Stop(0, "")
|
|
shown = tmux.show(epic.session, "TMUX" in epic.env)
|
|
return Stop(1, f"`tmux {' '.join(shown)}` failed; the chunks go on in the tmux session") if epic.effects.tmux_on_terminal(shown) else Stop(0, "")
|
|
|
|
|
|
def chunks_started(epic: EpicRun, issues: list[EpicIssue], own: str | None) -> scheduler.Started | Failure:
|
|
"""scheduler.start_chunks on the epic's issues, as read, and its cap, read afresh; own is the issue of the chunk that asks. Where no issue is open, the chunk to start is the epic's finishing, unless the epic is closed."""
|
|
closed = finish.due(issues) and epic.store.closed()
|
|
if isinstance(closed, Failure):
|
|
return closed
|
|
scheduled = scheduled_epic(epic)
|
|
if isinstance(scheduled, Failure):
|
|
return scheduled
|
|
started = scheduler.start_chunks(scheduled, issues, finish.due(issues) and not closed, own, epic.effects.tmux)
|
|
return started if isinstance(started, Failure) else dataclasses.replace(started, closed=closed)
|
|
|
|
|
|
def scheduled_epic(epic: EpicRun) -> scheduler.Epic | Failure:
|
|
"""The epic as scheduler limits its chunks: with its cap, read afresh, and each repo's checkout."""
|
|
cap = epic.record.parallel_chunks()
|
|
if isinstance(cap, Failure):
|
|
return cap
|
|
# The checkouts located so far, from whose remotes repos.locate tells where to clone a repo that is missing.
|
|
seen: list[pathlib.Path] = []
|
|
|
|
def located(name: str) -> tuple[pathlib.Path, int] | Failure:
|
|
found = locate(name, [checkout for checkout in seen], epic.config, epic.paths.home, epic.effects.git)
|
|
if isinstance(found, Failure):
|
|
return found
|
|
seen.append(found.checkout)
|
|
return real(found.checkout), found.config.parallel_chunks
|
|
|
|
return scheduler.Epic(epic.key, cap, located, epic.paths.home, epic.launcher, epic.env)
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True)
|
|
class RoutingIssue:
|
|
"""An issue as what routes its chunk (agent_cycle.routing.Scored)."""
|
|
issue: EpicIssue
|
|
|
|
@property
|
|
def id(self) -> int:
|
|
"""The number in the issue's key. A Route keeps a number, and one chunk's archive holds one issue, so the number tells the issue without its project's letters."""
|
|
return int(self.issue.key.rpartition("-")[2])
|
|
|
|
@property
|
|
def likelihood(self) -> int:
|
|
return self.issue.scores["L"]
|
|
|
|
@property
|
|
def escape_and_impact(self) -> int:
|
|
return self.issue.scores.get("E", 0) + self.issue.scores.get("I", 0)
|
|
|
|
|
|
def real(checkout: pathlib.Path) -> pathlib.Path:
|
|
"""The checkout as loop-claude names it, which is as git does: through no symlink or `..`. Each keys the checkout's lock and its chunks by that path, so a project config that spells it another way hides neither from the other."""
|
|
return checkout.resolve()
|
|
|
|
|
|
def chunk_run(key: str, epic: EpicRun) -> Stop:
|
|
"""Runs the cycles of the chunk of the issue called key until one stops the loop, or the judge rules the chunk finished. For a human's task it runs no cycle: it waits until the task no longer holds up an issue (`human_tasks.awaited`), then starts the next chunks. A chunk in a repo parks after each cycle that leaves its pull request waiting on a gate, and before its first where it was parked when its window last ended, as at a reboot."""
|
|
pane = epic.env.get("TMUX_PANE")
|
|
if not pane:
|
|
return Stop(1, f"{scheduler.CHUNK_FLAG} is how do-epic starts itself in a tmux window; run do-epic <EPIC-KEY>")
|
|
# None for the epic's finishing, which is no issue.
|
|
issue = None if key == epic.key else issue_read(key, epic)
|
|
if isinstance(issue, Stop):
|
|
return issue
|
|
if issue and isinstance(recorded(issue), HumanTask):
|
|
human_tasks.awaited(issue, epic.key, epic.store, tmux.Window(epic.session, key, pane), POLL_SECONDS, epic.paths.home, epic.effects)
|
|
return handed_on(key, epic)
|
|
place = chunk_root(key, issue, epic)
|
|
if isinstance(place, Stop):
|
|
return place
|
|
root, repo = place
|
|
session = session_named(f"A {epic.key} do-epic {key}", epic.paths.claude_code_transcripts)
|
|
loop = Loop(root=root, session=session, window=tmux.Window(epic.session, key, pane), paths=epic.paths, env=epic.env, launcher=epic.launcher, effects=epic.effects)
|
|
loop_run = LoopRun(0, root, "", "", chunk=key)
|
|
# What a chunk that was parked is told as it resumes; empty for a chunk that wasn't.
|
|
news = parked_through(repo, loop, epic, starts=True) if repo is not None else ""
|
|
while True:
|
|
if isinstance(news, Stop):
|
|
return news
|
|
loop_run = dataclasses.replace(loop_run, cycle_number=loop_run.cycle_number + 1)
|
|
cycle = next_cycle(loop_run, loop, repo is not None, epic, news)
|
|
if isinstance(cycle, Stop):
|
|
return cycle
|
|
loop_run = dataclasses.replace(loop_run, task=cycle.task)
|
|
concluded = run_cycle(cycle)
|
|
if isinstance(concluded, Stop):
|
|
return concluded
|
|
closed = closed_cycle(loop_run, cycle.project, concluded, cycle.project_archive, chunk_prompt.DRIVER, loop)
|
|
if isinstance(closed, Stop):
|
|
return closed
|
|
loop_run = closed
|
|
news = parked_through(repo, loop, epic, starts=False) if repo is not None else ""
|
|
# A chunk that was parked has work again, whatever the judge ruled before its pull request passed the gate.
|
|
if isinstance(concluded.verdict, Finished) and news == "":
|
|
return handed_on(key, epic)
|
|
|
|
|
|
def parked_through(repo: str, loop: Loop, epic: EpicRun, starts: bool) -> str | Stop:
|
|
"""Keeps the chunk in loop's window parked. Its work is in the repo called repo. It stays parked for as long as its pull request waits on a gate, and returns once its worker has something to do: what to tell that worker, or empty where the chunk was never parked. starts says the window just started, where the chunk is parked only if its file says so: the forge isn't read for a chunk that starts afresh.
|
|
|
|
A chunk parks in three steps: its file is written, its window is shown as parked, and the epic's next chunks start in the slot it frees. It resumes in the reverse order: `scheduler.resume` gives it a running slot, then its file is removed. So a window that ends in between finds the chunk parked when it starts again.
|
|
"""
|
|
key, folder = loop.window.name, epic.paths.home / scheduler.STATE / epic.key
|
|
recorded_as = parked.parked_chunks(folder)
|
|
if isinstance(recorded_as, Failure):
|
|
return Stop(1, recorded_as.reason)
|
|
if starts and key not in recorded_as:
|
|
return ""
|
|
# What the chunk is parked on; None while it isn't parked.
|
|
on = recorded_as[key].on if key in recorded_as else None
|
|
# What the window's name says the chunk awaits, and the last reason said for staying parked.
|
|
shown = said = None
|
|
while True:
|
|
now = gates.gate(key, loop.root, epic.forge_at)
|
|
if on is None and not isinstance(now, gates.Gate):
|
|
if isinstance(now, Failure):
|
|
say(f"cannot tell whether the chunk's pull request waits on a gate, so the chunk isn't parked: {now.reason}", epic.effects, stdout=True)
|
|
return ""
|
|
stays = None
|
|
if isinstance(now, gates.Gate) and now.on != on:
|
|
failed = parked.park(folder, parked.Parked(key, now.worktree, now.pull, str(loop.session.id), now.on))
|
|
if failed is not None:
|
|
return Stop(1, failed.reason)
|
|
say(f"parked: pull request #{now.pull} awaits {now.on}", epic.effects, stdout=True)
|
|
elif isinstance(now, Failure):
|
|
stays = f"cannot read the gate: {now.reason}"
|
|
elif isinstance(now, gates.Open):
|
|
full = resumed(repo, loop, epic)
|
|
if full is None:
|
|
failed = parked.unpark(folder, key)
|
|
return Stop(1, failed.reason) if failed is not None else f"{DRIVER_PARKED} its pull request awaited {on}. It resumes now: {now.news}."
|
|
stays = f"{now.news}, but the chunk stays parked: {full}"
|
|
awaits = parked.SLOT if isinstance(now, gates.Open) else now.on if isinstance(now, gates.Gate) else shown or on
|
|
if awaits != shown:
|
|
tmux.park(loop.window, str(awaits), epic.effects.tmux)
|
|
shown = awaits
|
|
if on is None:
|
|
# Once the window shows as parked, so the chunks that start count it as running nowhere.
|
|
issues = epic.store.read()
|
|
started = issues if isinstance(issues, Failure) else chunks_started(epic, issues, key)
|
|
say(f"could not start the next chunk: {started.reason}" if isinstance(started, Failure) else f"started {', '.join(started.started) or 'no other'}", epic.effects, stdout=True)
|
|
on = now.on if isinstance(now, gates.Gate) else on
|
|
if stays is not None and stays != said:
|
|
say(f"{stays}; trying again every {POLL_SECONDS} seconds", epic.effects, stdout=True)
|
|
said = stays
|
|
epic.effects.sleep(POLL_SECONDS)
|
|
|
|
|
|
# How the news for a chunk that was parked opens.
|
|
DRIVER_PARKED = f"{chunk_prompt.DRIVER} parked the chunk while"
|
|
|
|
|
|
def resumed(repo: str, loop: Loop, epic: EpicRun) -> str | None:
|
|
"""scheduler.resume for the parked chunk in loop's window, whose work is in the repo called repo, on the epic's cap and repos read afresh: None once it holds a running slot, else why it stays parked."""
|
|
scheduled = scheduled_epic(epic)
|
|
if isinstance(scheduled, Failure):
|
|
return scheduled.reason
|
|
return scheduler.resume(scheduled, repo, loop.window, epic.effects.tmux)
|
|
|
|
|
|
def issue_read(key: str, epic: EpicRun) -> EpicIssue | Stop:
|
|
"""The epic's issue called key, read afresh."""
|
|
issues = epic.store.read()
|
|
if isinstance(issues, Failure):
|
|
return Stop(1, issues.reason)
|
|
found = [issue for issue in issues if issue.key == key]
|
|
return found[0] if found else Stop(1, f"{key} is no issue of the epic {epic.key}")
|
|
|
|
|
|
def chunk_root(key: str, issue: EpicIssue | None, epic: EpicRun) -> tuple[str, str | None] | Stop:
|
|
"""The folder the chunk called key works in, and the name of the repo whose checkout it is: None for the epic's folder, which holds work without a repo, as the epic's finishing is. issue is None for the epic's finishing. The chunk keeps both to its end, whatever its issue's labels become. The stop where the labels make the issue no chunk."""
|
|
pick = recorded(issue) if issue else ClaudeWork()
|
|
if isinstance(pick, Failure):
|
|
return Stop(1, pick.reason)
|
|
if isinstance(pick, ClaudeWork):
|
|
folder = epic.paths.home / scheduler.STATE / epic.key
|
|
folder.mkdir(parents=True, exist_ok=True)
|
|
return str(folder), None
|
|
if not isinstance(pick, Repo):
|
|
return Stop(1, f"{key} is no chunk: no label names its repo")
|
|
found = locate(pick.name, [], epic.config, epic.paths.home, epic.effects.git)
|
|
return Stop(1, found.reason) if isinstance(found, Failure) else (str(real(found.checkout)), pick.name)
|
|
|
|
|
|
def handed_on(key: str, epic: EpicRun) -> Stop:
|
|
"""The stop of a do-epic whose chunk finished. It first moves the chunk's issue to done (the epic's finishing has none), and its split item too where that was the last of the item's sub-tasks, so that no finished chunk starts again and what they block may start, then starts each chunk that may start now. Its window closes as it exits."""
|
|
# The epic's finishing has no issue to move: the epic is closed by `--close-epic`.
|
|
moved = None if key == epic.key else epic.store.finish_issue(key)
|
|
if isinstance(moved, Failure):
|
|
return Stop(1, f"the chunk finished, but its issue could not move to done: {moved.reason}; once it is done in Jira, run `do-epic {epic.key}` to start the chunks it blocks")
|
|
issues = epic.store.read()
|
|
if isinstance(issues, Failure):
|
|
return Stop(1, f"the chunk finished, but the next could not start: {issues.reason}")
|
|
# A search may not show the move yet, so the issue counts as done here whatever the read says.
|
|
issues = [dataclasses.replace(each, done=True) if each.key == key else each for each in issues]
|
|
closed = split_items_closed(epic, issues)
|
|
if isinstance(closed, Stop):
|
|
return closed
|
|
started = chunks_started(epic, closed, key)
|
|
if isinstance(started, Failure):
|
|
return Stop(1, f"the chunk finished, but the next could not start: {started.reason}")
|
|
say(f"the chunk finished; started {', '.join(started.started) or 'no other'}", epic.effects, stdout=True)
|
|
return Stop(0, "")
|
|
|
|
|
|
def split_items_closed(epic: EpicRun, issues: list[EpicIssue]) -> list[EpicIssue] | Stop:
|
|
"""The issues, with each item split by repo whose sub-tasks are all done moved to done in the tracker and read as done; the stop where one cannot move. Its last sub-task to finish closes it, and one an earlier run left open closes with it."""
|
|
for item in issues:
|
|
if split.SPLIT_LABEL in item.labels and not item.done and split.finished(issues, item.key):
|
|
moved = epic.store.finish_issue(item.key)
|
|
if isinstance(moved, Failure):
|
|
return Stop(1, f"the chunk finished, but its split item {item.key} could not move to done: {moved.reason}; once it is done in Jira, run `do-epic {epic.key}` to start the chunks it blocks")
|
|
issues = [dataclasses.replace(each, done=True) if each.key == item.key else each for each in issues]
|
|
return issues
|
|
|
|
|
|
def next_cycle(loop_run: LoopRun, loop: Loop, in_repo: bool, epic: EpicRun, news: str = "") -> Cycle | Stop:
|
|
"""The cycle loop_run runs next, from the issue, the premises, the records, the models and the routing ladder read afresh; the stop where one of them cannot be read. news is what `parked_through` tells the worker of a chunk that was parked, and opens its prompt. A chunk in a repo routes on that repo's model and ladder, and one without a repo on the machine setting `repoless-model` and the shipped ladder."""
|
|
premises = premises_read(loop.root if in_repo else None, epic)
|
|
if isinstance(premises, Failure):
|
|
return Stop(1, premises.reason)
|
|
language = epic.record.language()
|
|
if isinstance(language, Failure):
|
|
return Stop(1, language.reason)
|
|
records = records_read(loop.root if in_repo else None, epic)
|
|
if isinstance(records, Failure):
|
|
return Stop(1, records.reason)
|
|
work = chunk_work(loop.window.name, loop.root if in_repo else None, language or epic.config.language, epic)
|
|
if isinstance(work, Stop):
|
|
return work
|
|
task, routing = work
|
|
models = get_or_ask_models(project_key(loop.root, epic.paths.home), epic.paths, epic.env, chunk_prompt.DRIVER, epic.effects) if in_repo else repoless_models(epic)
|
|
if isinstance(models, Stop):
|
|
return models
|
|
ladder_file = project_ladder_file(loop.root, epic.paths.home) if in_repo else SHIPPED
|
|
if isinstance(ladder_file, Failure):
|
|
return Stop(1, ladder_file.reason)
|
|
ladder = read_ladder(ladder_file)
|
|
if isinstance(ladder, Failure):
|
|
return Stop(1, ladder.reason)
|
|
archive_folder = epic.paths.home / ARCHIVE / epic.key
|
|
project = ladder.project_rung(models.worker)
|
|
route = routed(loop_run.route, project, models.worker, lambda: archived_route(archive_folder, loop), lambda: routing)
|
|
say(f"\n=== cycle {loop_run.cycle_number}, worker on {route.rung} ===", epic.effects, stdout=True)
|
|
return Cycle(config=setup_version(epic.paths.claude_dir, epic.effects.git), effects=epic.effects, facts="", judge=judge_rung(ladder, models.judge), premises=premises, project=project, project_archive=archive_folder, records=records, root=loop.root, route=route, session=loop.session, task=task, prompts=chunk_prompt.unparked(news) if news else chunk_prompt.restating(task) if loop_run.chunk == epic.key else chunk_prompt.WORKER, taken_in=lambda entries: TakenIn(), unfinished_evidence=loop_run.unfinished_evidence, window=loop.window)
|
|
|
|
|
|
def chunk_work(key: str, checkout: str | None, language: str, epic: EpicRun) -> tuple[str, RoutingIssue | None] | Stop:
|
|
"""The task of the chunk called key, and the issue that routes it, or None where that issue has no scores: both from the epic's issues, read afresh. The epic's finishing has no issue, and it ends here once the epic holds an open issue again, since working that issue comes first."""
|
|
if key != epic.key:
|
|
issue = issue_read(key, epic)
|
|
if isinstance(issue, Stop):
|
|
return issue
|
|
config = config_located(checkout, epic.paths.home) if checkout else None
|
|
if isinstance(config, Failure):
|
|
return Stop(1, config.reason)
|
|
return chunk_prompt.task(issue, epic.key, checkout, epic.launcher, language, config), RoutingIssue(issue) if "L" in issue.scores else None
|
|
issues = epic.store.read()
|
|
if isinstance(issues, Failure):
|
|
return Stop(1, issues.reason)
|
|
if not finish.due(issues):
|
|
say(f"the epic {epic.key} holds an open issue again, so its finishing chunk ends until none is open", epic.effects, stdout=True)
|
|
return handed_on(key, epic)
|
|
return finish.task(epic.key, issues, epic.launcher, language), None
|
|
|
|
|
|
def repoless_models(epic: EpicRun) -> Models:
|
|
"""The models of a chunk without a repo: `repoless-model`, unless the environment names another for the run, as it may for loop-claude."""
|
|
return Models(epic.env.get("LOOP_CLAUDE_JUDGE_MODEL") or epic.config.repoless_model, epic.env.get("LOOP_CLAUDE_WORKER_MODEL") or epic.config.repoless_model)
|
|
|
|
|
|
def records_read(root: str | None, epic: EpicRun) -> str | Failure:
|
|
"""The epic's Scoring and Decisions, from its description, then the records of the repo checked out at root, where the chunk has one, then the human's rules."""
|
|
sections: list[tuple[str, str]] = []
|
|
for name in ("Scoring", "Decisions"):
|
|
body = epic.record.section(name)
|
|
if isinstance(body, Failure):
|
|
return Failure(f"the epic {epic.key}'s description: {body.reason} - {CONSEQUENCE}.")
|
|
sections.append((f"the epic {epic.key}'s description, ## {name}", body))
|
|
return read_records(root, epic.paths.home, epic.paths.claude_dir, tuple(sections))
|
|
|
|
|
|
def premises_read(root: str | None, epic: EpicRun) -> str | Failure:
|
|
"""The epic's Goals and Audience, from its description, then those of the repo checked out at root, where the chunk has one. A Failure where the epic lacks either: no chunk runs without premises."""
|
|
bodies: list[str] = []
|
|
for name in ("Goals", "Audience"):
|
|
body = epic.record.section(name)
|
|
if isinstance(body, Failure):
|
|
return Failure(f"the epic {epic.key}'s description: {body.reason} - no premises.")
|
|
if not body.strip():
|
|
return Failure(f"the epic {epic.key}'s description has no text under a `## {name}` heading - no premises.")
|
|
bodies.append(body)
|
|
theirs = read_premises(root, epic.paths.home) if root else ""
|
|
if isinstance(theirs, Failure):
|
|
return theirs
|
|
return f"the epic {epic.key}'s description:\n## Goals\n{bodies[0]}\n\n## Audience\n{bodies[1]}" + (f"\n\nThe repo's goals, which rank after the epic's and after code health, are from {theirs}" if theirs else "")
|