loopx 0.4.8__py3-none-any.whl

loopx/control_plane/todos/active_state_editing.py

@@ -0,0 +1,296 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..goals.active_state_metadata import todo_role_for_heading
+from .contract import (
+    TODO_STATUS_DONE,
+    TODO_STATUS_OPEN,
+    TODO_TASK_PATTERN,
+    build_todo_id,
+    normalize_todo_status,
+    parse_todo_metadata_line,
+    todo_done_for_status,
+    todo_marker_for_status,
+    todo_status_from_marker,
+)
+from .text import normalize_new_todo
+from .todo_summary import normalize_todo_text
+
+
+TODO_SECTION_HEADINGS = {
+    "user": "User Todo / Owner Review Reading Queue",
+    "agent": "Agent Todo",
+}
+COMPLETED_WORK_ARCHIVE_HEADING = "Completed Work Archive"
+
+
+def section_bounds(lines: list[str], role: str) -> tuple[int, int, str] | None:
+    for index, line in enumerate(lines):
+        if not line.startswith("## "):
+            continue
+        heading = line.lstrip("#").strip()
+        if todo_role_for_heading(heading) != role:
+            continue
+        end = len(lines)
+        for next_index in range(index + 1, len(lines)):
+            if lines[next_index].startswith("## "):
+                end = next_index
+                break
+        return index, end, heading
+    return None
+
+
+def find_todo_block(
+    lines: list[str],
+    *,
+    todo_id: str,
+    role: str | None = None,
+) -> tuple[str, str, int, int, dict[str, Any]] | None:
+    roles = [role] if role else list(TODO_SECTION_HEADINGS)
+    for candidate_role in roles:
+        if candidate_role not in TODO_SECTION_HEADINGS:
+            continue
+        bounds = section_bounds(lines, candidate_role)
+        if not bounds:
+            continue
+        start, end, section = bounds
+        for block in todo_blocks(
+            lines,
+            start,
+            end,
+            role=candidate_role,
+            source_section=section,
+        ):
+            if block.get("todo_id") == todo_id:
+                return candidate_role, section, start, end, block
+    return None
+
+
+def todo_metadata_would_change(
+    lines: list[str],
+    block: dict[str, Any],
+    metadata_line: str | None,
+) -> bool:
+    if not metadata_line:
+        return False
+    start = int(block["start"])
+    end = int(block["end"])
+    for index in range(start + 1, end):
+        if parse_todo_metadata_line(lines[index]) is not None:
+            return lines[index] != metadata_line
+    return True
+
+
+def set_todo_marker(lines: list[str], block: dict[str, Any], status: str) -> bool:
+    marker = todo_marker_for_status(status)
+    index = int(block["start"])
+    updated = re.sub(
+        r"^(\s*[-*]\s+\[)[ xX-](\]\s+)",
+        rf"\1{marker}\2",
+        lines[index],
+        count=1,
+    )
+    if updated == lines[index]:
+        return False
+    lines[index] = updated
+    return True
+
+
+def set_todo_text(
+    lines: list[str],
+    block: dict[str, Any],
+    text: str,
+    *,
+    status: str,
+) -> bool:
+    normalized = normalize_new_todo(text)
+    if normalize_todo_text(str(block.get("text") or "")) == normalized:
+        return False
+
+    start = int(block["start"])
+    end = int(block["end"])
+    marker = todo_marker_for_status(status)
+    replacement = f"- [{marker}] {normalized}"
+    continuation_indexes = [
+        index
+        for index in range(start + 1, end)
+        if lines[index].startswith((" ", "\t"))
+        and parse_todo_metadata_line(lines[index]) is None
+    ]
+    lines[start] = replacement
+    for index in reversed(continuation_indexes):
+        del lines[index]
+    block["text"] = normalized
+    block["end"] = end - len(continuation_indexes)
+    return True
+
+
+def heading_index(lines: list[str], heading: str) -> int | None:
+    needle = f"## {heading}"
+    for index, line in enumerate(lines):
+        if line.strip() == needle:
+            return index
+    return None
+
+
+def insert_into_existing_section(lines: list[str], start: int, end: int, todo_line: str) -> None:
+    insert_at = end
+    while insert_at > start + 1 and not lines[insert_at - 1].strip():
+        insert_at -= 1
+    new_lines = todo_line.splitlines()
+    if insert_at == start + 1:
+        new_lines.insert(0, "")
+    if insert_at == end and end < len(lines) and lines[end].startswith("## "):
+        new_lines.append("")
+    lines[insert_at:insert_at] = new_lines
+
+
+def insertion_anchor(lines: list[str], role: str) -> int:
+    if role == "user":
+        agent_bounds = section_bounds(lines, "agent")
+        if agent_bounds:
+            return agent_bounds[0]
+    next_action = heading_index(lines, "Next Action")
+    if next_action is not None:
+        return next_action
+    return len(lines)
+
+
+def insert_new_section(lines: list[str], role: str, todo_line: str) -> None:
+    anchor = insertion_anchor(lines, role)
+    heading = TODO_SECTION_HEADINGS[role]
+    section = [f"## {heading}", "", *todo_line.splitlines(), ""]
+    if anchor > 0 and lines[anchor - 1].strip():
+        section.insert(0, "")
+    lines[anchor:anchor] = section
+
+
+def archive_section_bounds(lines: list[str]) -> tuple[int, int] | None:
+    start = heading_index(lines, COMPLETED_WORK_ARCHIVE_HEADING)
+    if start is None:
+        return None
+    end = len(lines)
+    for next_index in range(start + 1, len(lines)):
+        if lines[next_index].startswith("## "):
+            end = next_index
+            break
+    return start, end
+
+
+def ensure_archive_section(lines: list[str]) -> tuple[int, int]:
+    bounds = archive_section_bounds(lines)
+    if bounds:
+        return bounds
+    if lines and lines[-1].strip():
+        lines.append("")
+    start = len(lines)
+    lines.extend([f"## {COMPLETED_WORK_ARCHIVE_HEADING}", ""])
+    return start, len(lines)
+
+
+def ensure_block_identity(
+    block: dict[str, Any],
+    *,
+    role: str | None,
+    source_section: str | None,
+) -> dict[str, Any]:
+    if block.get("status"):
+        status = normalize_todo_status(block.get("status")) or TODO_STATUS_OPEN
+    else:
+        status = TODO_STATUS_DONE if block.get("done") else TODO_STATUS_OPEN
+    block["status"] = status
+    block["done"] = todo_done_for_status(status)
+    if not block.get("todo_id"):
+        block["todo_id"] = build_todo_id(
+            role=role,
+            source_section=source_section,
+            index=block.get("index"),
+            text=block.get("text"),
+        )
+    return block
+
+
+def todo_blocks(
+    lines: list[str],
+    start: int,
+    end: int,
+    *,
+    role: str | None = None,
+    source_section: str | None = None,
+) -> list[dict[str, Any]]:
+    blocks: list[dict[str, Any]] = []
+    current: dict[str, Any] | None = None
+    todo_index = 0
+    for index in range(start + 1, end):
+        match = TODO_TASK_PATTERN.match(lines[index])
+        if match:
+            if current is not None:
+                current["end"] = index
+                ensure_block_identity(current, role=role, source_section=source_section)
+                blocks.append(current)
+            marker, text = match.groups()
+            todo_index += 1
+            status = todo_status_from_marker(marker)
+            current = {
+                "start": index,
+                "end": end,
+                "index": todo_index,
+                "done": todo_done_for_status(status),
+                "status": status,
+                "text": normalize_todo_text(text),
+            }
+            continue
+        if current is not None and lines[index].startswith((" ", "\t")):
+            metadata = parse_todo_metadata_line(lines[index])
+            if metadata:
+                current.update(metadata)
+                continue
+            continuation = lines[index].strip()
+            if continuation:
+                current["text"] = normalize_todo_text(
+                    f"{current.get('text', '')} {continuation}"
+                )
+    if current is not None:
+        current["end"] = end
+        ensure_block_identity(current, role=role, source_section=source_section)
+        blocks.append(current)
+    return blocks
+
+
+def insert_archive_blocks(lines: list[str], blocks: list[list[str]]) -> None:
+    if not blocks:
+        return
+    bounds = ensure_archive_section(lines)
+    insert_at = bounds[1]
+    while insert_at > bounds[0] + 1 and not lines[insert_at - 1].strip():
+        insert_at -= 1
+    new_lines: list[str] = []
+    if insert_at == bounds[0] + 1:
+        new_lines.append("")
+    for block in blocks:
+        new_lines.extend(block)
+    if insert_at < len(lines) and lines[insert_at].startswith("## "):
+        new_lines.append("")
+    lines[insert_at:insert_at] = new_lines
+
+
+def replace_updated_at(text: str, updated_at: str) -> str:
+    if not text.startswith("---"):
+        return text
+    parts = text.split("---", 2)
+    if len(parts) < 3:
+        return text
+    frontmatter = parts[1]
+    body = parts[2]
+    if re.search(r"(?m)^updated_at:\s*.+$", frontmatter):
+        frontmatter = re.sub(
+            r"(?m)^updated_at:\s*.+$",
+            f"updated_at: {updated_at}",
+            frontmatter,
+            count=1,
+        )
+    else:
+        frontmatter = frontmatter.rstrip("\n") + f"\nupdated_at: {updated_at}\n"
+    return "---" + frontmatter + "---" + body

loopx/control_plane/todos/active_state_todo_parser.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from ...materials import extract_review_materials
+from ...orchestration import compact_orchestration_policy
+from ..goals.active_state_metadata import (
+    TODO_ARCHIVE_HEADER_MARKERS,
+    todo_role_for_heading,
+)
+from .contract import (
+    TODO_TASK_PATTERN,
+    normalize_todo_id,
+    parse_todo_metadata_line,
+    todo_done_for_status,
+    todo_status_from_marker,
+)
+from .decision_scope import build_standing_decision_authority
+from .todo_summary import (
+    MAX_STATUS_TODOS_PER_ROLE,
+    compact_todo_group,
+    normalize_todo_text,
+)
+
+
+def parse_active_state_todos(
+    state_text: str,
+    *,
+    goal: dict[str, Any] | None = None,
+    state_path: Path | None = None,
+    preferred_todo_ids: set[str] | None = None,
+    rollout_events: list[dict[str, Any]] | None = None,
+    item_limit: int | None = MAX_STATUS_TODOS_PER_ROLE,
+) -> dict[str, Any]:
+    orchestration = compact_orchestration_policy(
+        goal.get("spawn_policy") if isinstance(goal, dict) else None
+    )
+    include_task_orchestration_authority = bool(
+        orchestration.get("mode") == "multi_subagent"
+        and orchestration.get("spawn_allowed") is True
+        and int(orchestration.get("max_children") or 0) > 0
+    )
+    role: str | None = None
+    source_sections: dict[str, str | None] = {"user": None, "agent": None}
+    items: dict[str, list[dict[str, Any]]] = {"user": [], "agent": []}
+    archive_items: list[dict[str, Any]] = []
+    archive_mode = False
+    archive_source_section: str | None = None
+    current_todo: dict[str, Any] | None = None
+
+    for line in state_text.splitlines():
+        if line.startswith("## "):
+            heading = line.lstrip("#").strip()
+            normalized_heading = heading.strip().lower()
+            archive_mode = any(
+                marker in normalized_heading for marker in TODO_ARCHIVE_HEADER_MARKERS
+            )
+            archive_source_section = heading if archive_mode else None
+            role = todo_role_for_heading(heading)
+            current_todo = None
+            if role and source_sections[role] is None:
+                source_sections[role] = heading
+            continue
+        if role is None and not archive_mode:
+            continue
+        match = TODO_TASK_PATTERN.match(line)
+        if match:
+            marker, text = match.groups()
+            status = todo_status_from_marker(marker)
+            target_items = archive_items if archive_mode else items[str(role)]
+            todo: dict[str, Any] = {
+                "index": len(target_items) + 1,
+                "done": todo_done_for_status(status),
+                "status": status,
+                "text": normalize_todo_text(text),
+            }
+            if archive_mode:
+                todo["archive_state"] = "archive"
+                todo["source_section"] = archive_source_section
+            else:
+                todo["archive_state"] = "active"
+                todo["source_section"] = source_sections[str(role)]
+                todo["role"] = role
+            if goal is not None:
+                materials = extract_review_materials(text, goal=goal, state_path=state_path)
+                if materials:
+                    todo["review_materials"] = materials
+            target_items.append(todo)
+            current_todo = todo
+            continue
+        if current_todo is None or not line.startswith((" ", "\t")):
+            continue
+        metadata = parse_todo_metadata_line(line)
+        if metadata:
+            current_todo.update(metadata)
+            continue
+        continuation = line.strip()
+        if continuation:
+            current_todo["text"] = normalize_todo_text(
+                f"{current_todo.get('text', '')} {continuation}"
+            )
+
+    result: dict[str, Any] = {}
+    archived_resume_source_items = [
+        item for item in archive_items if normalize_todo_id(item.get("todo_id"))
+    ]
+    resume_source_items = [*items["user"], *items["agent"], *archived_resume_source_items]
+    user = compact_todo_group(
+        items["user"],
+        source_section=source_sections["user"],
+        role="user",
+        include_empty_source=source_sections["user"] is not None,
+        preferred_todo_ids=preferred_todo_ids,
+        resume_source_items=resume_source_items,
+        rollout_events=rollout_events,
+        item_limit=item_limit,
+        include_task_orchestration_authority=include_task_orchestration_authority,
+    )
+    agent = compact_todo_group(
+        items["agent"],
+        source_section=source_sections["agent"],
+        role="agent",
+        include_empty_source=source_sections["agent"] is not None,
+        preferred_todo_ids=preferred_todo_ids,
+        resume_source_items=resume_source_items,
+        rollout_events=rollout_events,
+        item_limit=item_limit,
+        include_task_orchestration_authority=include_task_orchestration_authority,
+    )
+    if user:
+        result["user_todos"] = user
+    if agent:
+        result["agent_todos"] = agent
+    standing_authority = build_standing_decision_authority(items["user"])
+    if standing_authority:
+        result["standing_decision_authority"] = standing_authority
+    return result

loopx/control_plane/todos/active_state_todos.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+MONITOR_WRITEBACK_CONTRACT_SCHEMA_VERSION = "monitor_writeback_contract_v0"
+
+
+def _attach_monitor_writeback_contract(
+    fields: dict[str, Any],
+    *,
+    supported: bool,
+    source: str,
+) -> None:
+    if supported:
+        return
+    contract = {
+        "schema_version": MONITOR_WRITEBACK_CONTRACT_SCHEMA_VERSION,
+        "supported": False,
+        "source": source,
+    }
+    for key in ("user_todos", "agent_todos"):
+        summary = fields.get(key)
+        if isinstance(summary, dict):
+            summary["monitor_writeback"] = dict(contract)
+
+
+def attach_monitor_writeback_contract(
+    fields: dict[str, Any],
+    *,
+    supported: bool,
+    source: str,
+) -> None:
+    _attach_monitor_writeback_contract(fields, supported=supported, source=source)
+
+
+def _redacted_status_todo_fields(fields: dict[str, Any]) -> dict[str, Any]:
+    redacted = dict(fields)
+    for key in ("user_todos", "agent_todos"):
+        group = redacted.get(key)
+        if not isinstance(group, dict):
+            continue
+        group_copy = dict(group)
+        items: list[Any] = []
+        for item in group_copy.get("items") or []:
+            if not isinstance(item, dict):
+                items.append(item)
+                continue
+            item_copy = dict(item)
+            materials = item_copy.get("review_materials")
+            if isinstance(materials, list):
+                redacted_materials = []
+                for material in materials:
+                    if not isinstance(material, dict):
+                        redacted_materials.append(material)
+                        continue
+                    material_copy = dict(material)
+                    material_copy.pop("resolved_path", None)
+                    redacted_materials.append(material_copy)
+                item_copy["review_materials"] = redacted_materials
+            items.append(item_copy)
+        group_copy["items"] = items
+        redacted[key] = group_copy
+    return redacted
+
+
+def redacted_status_todo_fields(fields: dict[str, Any]) -> dict[str, Any]:
+    return _redacted_status_todo_fields(fields)
+
+
+def active_state_todo_fields(
+    goal: dict[str, Any],
+    *,
+    runtime_root: Path | None = None,
+    resolve_goal_local_path: Callable[..., Path | None],
+    active_state_next_action_entries: Callable[..., list[str]],
+    active_next_action_todo_ids: Callable[[str], set[str]],
+    load_rollout_events: Callable[..., list[dict[str, Any]]],
+    rollout_event_log_path: Callable[[Path, str], Path],
+    max_todo_index_rollout_events_per_goal: int,
+    active_state_event_projection_fields: Callable[..., dict[str, Any]],
+    parse_active_state_todos: Callable[..., dict[str, Any]],
+    parse_issue_meta_surface: Callable[[str], dict[str, Any] | None],
+    backlog_hygiene_warning: Callable[..., dict[str, Any] | None],
+    completed_todo_archive_warning: Callable[[dict[str, Any] | None], dict[str, Any] | None],
+    state_projection_gap_warning: Callable[..., dict[str, Any] | None],
+    attach_monitor_writeback_contract: Callable[..., None] | None = None,
+    redacted_status_todo_fields: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    monitor_writeback_contract_writer = attach_monitor_writeback_contract or _attach_monitor_writeback_contract
+    todo_field_redactor = redacted_status_todo_fields or _redacted_status_todo_fields
+    state_path = resolve_goal_local_path(goal.get("state_file"), goal, fallback_base=Path.cwd())
+    if state_path is None or not state_path.exists():
+        return {}
+    try:
+        state_text = state_path.read_text(encoding="utf-8")
+    except OSError:
+        return {}
+    next_action_entries = active_state_next_action_entries(state_text, limit=3)
+    preferred_todo_ids: set[str] = set()
+    for entry in next_action_entries:
+        preferred_todo_ids.update(active_next_action_todo_ids(entry))
+    rollout_events: list[dict[str, Any]] = []
+    goal_id = str(goal.get("id") or "").strip()
+    if runtime_root is not None and goal_id:
+        rollout_events = load_rollout_events(
+            rollout_event_log_path(runtime_root, goal_id),
+            limit=max_todo_index_rollout_events_per_goal,
+        )
+    event_fields = active_state_event_projection_fields(
+        goal,
+        state_path=state_path,
+        preferred_todo_ids=preferred_todo_ids,
+        rollout_events=rollout_events,
+    )
+    if event_fields.get("user_todos") or event_fields.get("agent_todos"):
+        fields = event_fields
+        markdown_fields = parse_active_state_todos(
+            state_text,
+            goal=goal,
+            state_path=state_path,
+            preferred_todo_ids=preferred_todo_ids,
+            rollout_events=rollout_events,
+        )
+        standing_decision_authority = markdown_fields.get("standing_decision_authority")
+        if isinstance(standing_decision_authority, dict):
+            fields["standing_decision_authority"] = standing_decision_authority
+        monitor_writeback_contract_writer(
+            fields,
+            supported=False,
+            source="event_projection_read_model",
+        )
+    else:
+        fields = parse_active_state_todos(
+            state_text,
+            goal=goal,
+            state_path=state_path,
+            preferred_todo_ids=preferred_todo_ids,
+            rollout_events=rollout_events,
+        )
+        monitor_writeback_contract_writer(
+            fields,
+            supported=True,
+            source="markdown_active_state",
+        )
+        if event_fields:
+            fields.update(event_fields)
+    issue_meta_surface = parse_issue_meta_surface(state_text)
+    if issue_meta_surface:
+        fields["issue_meta_surface"] = issue_meta_surface
+    if next_action_entries:
+        fields["active_state_next_action"] = next_action_entries[0]
+        fields["active_state_next_action_entries"] = next_action_entries
+    warning = backlog_hygiene_warning(
+        state_text,
+        agent_todos=fields.get("agent_todos") if isinstance(fields.get("agent_todos"), dict) else None,
+    )
+    if warning:
+        fields["backlog_hygiene_warning"] = warning
+    archive_warning = completed_todo_archive_warning(
+        fields.get("agent_todos") if isinstance(fields.get("agent_todos"), dict) else None
+    )
+    if archive_warning:
+        fields["completed_todo_archive_warning"] = archive_warning
+    projection_gap = state_projection_gap_warning(
+        state_text,
+        user_todos=fields.get("user_todos") if isinstance(fields.get("user_todos"), dict) else None,
+        agent_todos=fields.get("agent_todos") if isinstance(fields.get("agent_todos"), dict) else None,
+    )
+    if projection_gap:
+        fields["state_projection_gap"] = projection_gap
+    if fields:
+        fields = todo_field_redactor(fields)
+    return fields