95 lines
4.8 KiB
Python
95 lines
4.8 KiB
Python
import dataclasses
|
|
import sys
|
|
import typing
|
|
import uuid
|
|
|
|
from loop_claude.hand_over import claude_args, ClaudeCommand, hand_over
|
|
from loop_effects.effects import Effects, say
|
|
from failure import Failure
|
|
from claude_code.transcript import human_turns, read_transcript
|
|
from loop_claude.stop import needs_human, needs_terminal, Stop
|
|
from model_routing.ladder import Rung
|
|
from loop_claude.direct_message import tell
|
|
from loop_claude import tmux
|
|
|
|
ANSWER_QUESTION = "answer the question above"
|
|
# TALK, what the human types at loop-claude's terminal to open claude for the question, and ASK_ANSWER were picked on 2026-10-17 by a bench of three readers seated as the README's audience, as ~/.claude/CLAUDE.md → "Working loop" → "Bench a syntax with the people who write it." has it.
|
|
TALK = "/talk"
|
|
ASK_ANSWER = f"Answer ({TALK} opens claude, Enter stops the loop): "
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True)
|
|
class WorkerSession:
|
|
"""The worker's claude session, which /talk opens on loop-claude's terminal."""
|
|
root: str
|
|
id: uuid.UUID
|
|
rung: Rung
|
|
transcript_path: str
|
|
# Added to the environment of the worker's claude, and of the claude /talk opens.
|
|
env: dict[str, str]
|
|
|
|
def claude_command(self) -> ClaudeCommand:
|
|
return ClaudeCommand(claude_args(self.rung, ["--resume", str(self.id)]), self.root, self.env)
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True)
|
|
class Talked:
|
|
"""The human typed in the worker's claude session."""
|
|
|
|
|
|
def interrupt(question: str, answer_here: bool, session: WorkerSession, window: tmux.Window, effects: Effects) -> str | Talked | Stop:
|
|
"""Prints question for the human, in window, and returns their answer. While it waits, the window's name ends in tmux.WAITS, and the bell it rings shows in tmux's status bar. The answer: where answer_here, the first line typed at loop-claude's terminal, stripped, or Talked once they typed in the worker's claude session, which TALK opens; else Talked once they typed in that session, which opens at once on the terminal. A Stop where loop-claude is off a terminal, or they type no answer, or the input ends."""
|
|
# The bell ends the question's line, so it rings once the question can be read.
|
|
say(f"\n{question}{tmux.BELL}", effects)
|
|
on_terminal = effects.on_terminal()
|
|
if on_terminal:
|
|
# Keys typed while the worker ran wait on the terminal, and would answer a question no one has read, here or in claude's session, which reads them too. Of a pasted answer, the first line answers; the rest wait, and the next question drops them. A longer answer goes through TALK.
|
|
effects.discard_typed()
|
|
tmux.mark(window, True, effects.tmux)
|
|
# After the discard, so an answer typed while the DM sends counts; before the terminal check, so a loop that cannot ask still tells the human what it would have asked.
|
|
tell(f"loop-claude in {session.root} asks, in the tmux window {window.target}:\n\n{question}", effects)
|
|
answer = needs_terminal(ANSWER_QUESTION, on_terminal) or answered(answer_here, session, effects)
|
|
# A loop that stops unanswered leaves the mark on its window.
|
|
if not isinstance(answer, Stop):
|
|
tmux.mark(window, False, effects.tmux)
|
|
return answer
|
|
|
|
|
|
def answered(answer_here: bool, session: WorkerSession, effects: Effects) -> str | Talked | Stop:
|
|
"""The human's answer, as interrupt returns it."""
|
|
answer = typed_answer(effects) if answer_here else TALK
|
|
if answer != TALK:
|
|
return answer
|
|
return human_typed(session.transcript_path, lambda: claude_open(session, effects)) or Talked()
|
|
|
|
|
|
def typed_answer(effects: Effects) -> str | Stop:
|
|
"""The line typed at loop-claude's terminal, stripped. A Stop where they type no answer, or the input ends."""
|
|
try:
|
|
text = effects.input(ASK_ANSWER).strip()
|
|
except EOFError:
|
|
print(file=sys.stderr) # Ends the prompt's line. It isn't a message, so it gets no time.
|
|
return needs_human(ANSWER_QUESTION, "the input ended")
|
|
return text or needs_human(ANSWER_QUESTION, "nothing was typed")
|
|
|
|
|
|
def claude_open(session: WorkerSession, effects: Effects) -> Stop | None:
|
|
"""Opens the worker's claude session on the terminal, and returns once it has ended."""
|
|
if unstarted := hand_over(session.claude_command(), effects):
|
|
return Stop(1, f"could not start claude for the interrupt: {unstarted.reason}")
|
|
return None
|
|
|
|
|
|
def human_typed(transcript_path: str, held_open: typing.Callable[[], Stop | None]) -> Stop | None:
|
|
"""Runs held_open, which returns once the claude the human answers in has ended, then checks that the human typed something there."""
|
|
entries = read_transcript(transcript_path)
|
|
if isinstance(entries, Failure):
|
|
return Stop(1, entries.reason)
|
|
before = human_turns(entries)
|
|
if stop := held_open():
|
|
return stop
|
|
entries = read_transcript(transcript_path)
|
|
if isinstance(entries, Failure):
|
|
return Stop(1, f"could not tell whether you typed anything: {entries.reason}")
|
|
return None if human_turns(entries) > before else needs_human(ANSWER_QUESTION, "the interrupt ended without anything typed")
|