Step Three: One Todo, One Report

"""step3_todo.py: one todos table, one tool, a worker you start yourself,
one report row per todo, and a naive compaction that keeps every original line.
Stdlib only. Run:  python3 step3_todo.py demo     (or: chat TEXT / work / deliver)
"""
import json, sqlite3, sys, uuid
from pathlib import Path

DATA = Path("todo-data")
LOG, DB = DATA / "default.jsonl", DATA / "todos.db"
COMPACT_AT, KEEP_LAST = 10, 4        # replay rows that trigger a pass; rows kept verbatim
TOOLS = [{"name": "add_todo", "description": "Queue a task for a worker. Only when asked.",
          "input_schema": {"type": "object", "properties": {"title": {"type": "string"}}}}]


def call_model(system, messages, tools):
    """STUB: your model call, with `tools` offered. Return {"text": ...} or
    {"tool": name, "args": {...}}. The fake calls the tool on 'todo: ...'."""
    last = messages[-1]["content"]
    if last.startswith("todo:"):
        return {"tool": "add_todo", "args": {"title": last[5:].strip()}}
    return {"text": f"(fake) {len(messages)} messages in my replay"}


def summarize(messages):
    """STUB: a model call that summarizes. The fake keeps each line's first words."""
    return "[Summary of earlier turns] " + " | ".join(m["content"][:22] for m in messages)


def db():
    conn = sqlite3.connect(DB)
    conn.execute("CREATE TABLE IF NOT EXISTS todos (id INTEGER PRIMARY KEY, title TEXT NOT NULL,"
                 " status TEXT NOT NULL DEFAULT 'open', report TEXT, source_row TEXT)")
    return conn


def rows():
    return [json.loads(l) for l in LOG.read_text().splitlines() if l] if LOG.exists() else []


def append(row):
    row = {"id": uuid.uuid4().hex[:8], **row}
    with LOG.open("a") as f:
        f.write(json.dumps(row) + "\n")
    return row["id"]


def replay():
    """The newest summary, then every row it did not take. Nothing is deleted."""
    every = rows()
    marks = [r for r in every if r["kind"] == "compaction"]
    gone = {i for m in marks for i in m["compacted_ids"]}
    head = [{"role": "user", "content": marks[-1]["summary"], "id": None}] if marks else []
    live = [r for r in every if r["kind"] in ("user", "assistant", "report") and r["id"] not in gone]
    return head + [{"role": "user" if r["kind"] == "user" else "assistant",
                    "content": r["content"], "id": r["id"]} for r in live]


def compact_if_needed():
    msgs = replay()
    if len(msgs) <= COMPACT_AT:
        return
    old = msgs[:-KEEP_LAST]                           # includes the previous summary, if any
    append({"kind": "compaction", "summary": summarize(old),
            "compacted_ids": [m["id"] for m in old if m["id"]]})


def chat(text):
    asked = append({"kind": "user", "content": text})  # not rows()[-1]: a compaction
    compact_if_needed()                                # may land after this row
    msgs = replay()
    out = call_model("You are Pip.", [{"role": m["role"], "content": m["content"]} for m in msgs], TOOLS)
    if out.get("tool") == "add_todo":                 # the one tool, run by your code
        with db() as conn:
            todo = conn.execute("INSERT INTO todos (title, source_row) VALUES (?, ?)",
                                (out["args"]["title"], asked)).lastrowid
        reply = f"Queued as todo #{todo}."            # a real loop sends the result back to the model
    else:
        reply = out["text"]
    append({"kind": "assistant", "content": reply})
    print(f"you> {text}\npip> {reply}")


def work():
    """The worker YOU start. It takes the oldest open todo and reports in one line."""
    with db() as conn:
        row = conn.execute("SELECT id, title FROM todos WHERE status='open' ORDER BY id").fetchone()
        if row:
            report = f"Done: {row[1]} (3 items, saved to notes)."   # pretend work
            conn.execute("UPDATE todos SET status='done', report=? WHERE id=? AND status='open'",
                         (report, row[0]))
    print(f"worker: todo #{row[0]} done" if row else "worker: nothing open")


def deliver():
    """Append each finished todo's report once, keyed by the todo id. The key is
    looked up in the RECORD (every line), never the replay, so compaction cannot
    make a delivered report look undelivered."""
    landed = {r.get("key") for r in rows()}
    count = 0
    with db() as conn:
        for todo, report in conn.execute("SELECT id, report FROM todos WHERE status='done' ORDER BY id"):
            if f"todo-report:{todo}" not in landed:
                append({"kind": "report", "key": f"todo-report:{todo}", "content": report})
                count += 1
    print(f"deliver: {count} new report row(s)")


def demo():
    DATA.mkdir(exist_ok=True)
    for p in (LOG, DB):
        p.unlink(missing_ok=True)
    chat("hello")
    chat("todo: draft the packing list")
    work()
    deliver()
    deliver()                                          # a retry: lands nothing
    for i in range(1, 5):
        chat(f"small talk {i}")
    every, msgs = rows(), replay()
    print(f"file: {len(every)} lines | replay: {len(msgs)} messages")
    print(f"replay starts: {msgs[0]['content'][:72]}...")
    deliver()                                          # after compaction: still nothing


if __name__ == "__main__":
    DATA.mkdir(exist_ok=True)
    cmd = sys.argv[1] if len(sys.argv) > 1 else "demo"
    {"demo": demo, "work": work, "deliver": deliver}.get(cmd, lambda: chat(" ".join(sys.argv[2:])))()

$ python3 step3_todo.py demo
you> hello
pip> (fake) 1 messages in my replay
you> todo: draft the packing list
pip> Queued as todo #1.
worker: todo #1 done
deliver: 1 new report row(s)
deliver: 0 new report row(s)
you> small talk 1
pip> (fake) 6 messages in my replay
you> small talk 2
pip> (fake) 8 messages in my replay
you> small talk 3
pip> (fake) 10 messages in my replay
you> small talk 4
pip> (fake) 5 messages in my replay
file: 14 lines | replay: 6 messages
replay starts: [Summary of earlier turns] hello | (fake) 1 messages in m | todo: draft ...
deliver: 0 new report row(s)