315 lines
8.6 KiB
Python
315 lines
8.6 KiB
Python
"""
|
|
Models - Core data structures for MMA orchestration and project configuration.
|
|
|
|
This module defines the primary dataclasses used throughout the Manual Slop
|
|
application for representing tasks, tracks, and execution context.
|
|
|
|
Key Data Structures:
|
|
- Ticket: Atomic unit of work with status, dependencies, and context requirements
|
|
- Track: Collection of tickets with a shared goal
|
|
- WorkerContext: Execution context for a Tier 3 worker
|
|
- Metadata: Track metadata (id, name, status, timestamps)
|
|
- TrackState: Serializable track state with discussion history
|
|
- FileItem: File configuration with auto-aggregate and force-full flags
|
|
|
|
Status Machine (Ticket):
|
|
todo -> in_progress -> completed
|
|
| |
|
|
v v
|
|
blocked blocked
|
|
|
|
Serialization:
|
|
All dataclasses provide to_dict() and from_dict() class methods for TOML/JSON
|
|
persistence via project_manager.py.
|
|
|
|
Thread Safety:
|
|
These dataclasses are NOT thread-safe. Callers must synchronize mutations
|
|
if sharing instances across threads (e.g., during ConductorEngine execution).
|
|
|
|
Configuration Integration:
|
|
- load_config() / save_config() read/write the global config.toml
|
|
- AGENT_TOOL_NAMES defines the canonical list of MCP tools available to agents
|
|
|
|
See Also:
|
|
- docs/guide_mma.md for MMA orchestration documentation
|
|
- src/dag_engine.py for TrackDAG and ExecutionEngine
|
|
- src/multi_agent_conductor.py for ConductorEngine
|
|
- src/project_manager.py for persistence layer
|
|
"""
|
|
from __future__ import annotations
|
|
import tomllib
|
|
import datetime
|
|
from dataclasses import dataclass, field
|
|
from typing import List, Optional, Dict, Any, Union
|
|
from pathlib import Path
|
|
from src.paths import get_config_path
|
|
|
|
CONFIG_PATH = get_config_path()
|
|
|
|
def load_config() -> dict[str, Any]:
|
|
with open(CONFIG_PATH, "rb") as f:
|
|
return tomllib.load(f)
|
|
|
|
def save_config(config: dict[str, Any]) -> None:
|
|
import tomli_w
|
|
with open(CONFIG_PATH, "wb") as f:
|
|
tomli_w.dump(config, f)
|
|
|
|
AGENT_TOOL_NAMES = [
|
|
"run_powershell",
|
|
"read_file",
|
|
"list_directory",
|
|
"search_files",
|
|
"web_search",
|
|
"fetch_url",
|
|
"get_file_summary",
|
|
"py_get_skeleton",
|
|
"py_get_code_outline",
|
|
"py_get_definition",
|
|
"py_get_signature",
|
|
"py_get_class_summary",
|
|
"py_get_var_declaration",
|
|
"py_get_docstring",
|
|
"py_find_usages",
|
|
"py_get_imports",
|
|
"py_check_syntax",
|
|
"py_get_hierarchy"
|
|
]
|
|
|
|
def parse_history_entries(history_strings: list[str], roles: list[str]) -> list[dict[str, Any]]:
|
|
import re
|
|
entries = []
|
|
for raw in history_strings:
|
|
ts = ""
|
|
rest = raw
|
|
if rest.startswith("@"):
|
|
nl = rest.find("\n")
|
|
if nl != -1:
|
|
ts = rest[1:nl]
|
|
rest = rest[nl + 1:]
|
|
known = roles or ["User", "AI", "Vendor API", "System"]
|
|
role_pat = re.compile(r"^(" + "|".join(re.escape(r) for r in known) + r"):", re.IGNORECASE)
|
|
match = role_pat.match(rest)
|
|
role = match.group(1) if match else "User"
|
|
if match:
|
|
content = rest[match.end():].strip()
|
|
else:
|
|
content = rest
|
|
entries.append({"role": role, "content": content, "collapsed": True, "ts": ts})
|
|
return entries
|
|
|
|
@dataclass
|
|
class Ticket:
|
|
id: str
|
|
description: str
|
|
status: str = "todo"
|
|
assigned_to: str = "unassigned"
|
|
priority: str = "medium"
|
|
target_file: Optional[str] = None
|
|
target_symbols: List[str] = field(default_factory=list)
|
|
context_requirements: List[str] = field(default_factory=list)
|
|
depends_on: List[str] = field(default_factory=list)
|
|
blocked_reason: Optional[str] = None
|
|
step_mode: bool = False
|
|
retry_count: int = 0
|
|
manual_block: bool = False
|
|
model_override: Optional[str] = None
|
|
|
|
def mark_blocked(self, reason: str) -> None:
|
|
self.status = "blocked"
|
|
self.blocked_reason = reason
|
|
|
|
def mark_manual_block(self, reason: str) -> None:
|
|
self.status = "blocked"
|
|
self.blocked_reason = f"[MANUAL] {reason}"
|
|
self.manual_block = True
|
|
|
|
def clear_manual_block(self) -> None:
|
|
if self.manual_block:
|
|
self.status = "todo"
|
|
self.blocked_reason = None
|
|
self.manual_block = False
|
|
|
|
def mark_complete(self) -> None:
|
|
self.status = "completed"
|
|
|
|
def get(self, key: str, default: Any = None) -> Any:
|
|
return getattr(self, key, default)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return {
|
|
"id": self.id,
|
|
"description": self.description,
|
|
"status": self.status,
|
|
"assigned_to": self.assigned_to,
|
|
"priority": self.priority,
|
|
"target_file": self.target_file,
|
|
"target_symbols": self.target_symbols,
|
|
"context_requirements": self.context_requirements,
|
|
"depends_on": self.depends_on,
|
|
"blocked_reason": self.blocked_reason,
|
|
"step_mode": self.step_mode,
|
|
"retry_count": self.retry_count,
|
|
"manual_block": self.manual_block,
|
|
"model_override": self.model_override,
|
|
}
|
|
|
|
@classmethod
|
|
def from_dict(cls, data: Dict[str, Any]) -> "Ticket":
|
|
return cls(
|
|
id=data["id"],
|
|
description=data.get("description", ""),
|
|
status=data.get("status", "todo"),
|
|
assigned_to=data.get("assigned_to", "unassigned"),
|
|
priority=data.get("priority", "medium"),
|
|
target_file=data.get("target_file"),
|
|
target_symbols=data.get("target_symbols", []),
|
|
context_requirements=data.get("context_requirements", []),
|
|
depends_on=data.get("depends_on", []),
|
|
blocked_reason=data.get("blocked_reason"),
|
|
step_mode=data.get("step_mode", False),
|
|
retry_count=data.get("retry_count", 0),
|
|
manual_block=data.get("manual_block", False),
|
|
model_override=data.get("model_override"),
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class Track:
|
|
id: str
|
|
description: str
|
|
tickets: List[Ticket] = field(default_factory=list)
|
|
|
|
def get_executable_tickets(self) -> List[Ticket]:
|
|
from src.dag_engine import TrackDAG
|
|
dag = TrackDAG(self.tickets)
|
|
return dag.get_ready_tasks()
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return {
|
|
"id": self.id,
|
|
"description": self.description,
|
|
"tickets": [t.to_dict() for t in self.tickets],
|
|
}
|
|
|
|
@classmethod
|
|
def from_dict(cls, data: Dict[str, Any]) -> "Track":
|
|
return cls(
|
|
id=data["id"],
|
|
description=data.get("description", ""),
|
|
tickets=[Ticket.from_dict(t) for t in data.get("tickets", [])],
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class WorkerContext:
|
|
ticket_id: str
|
|
model_name: str
|
|
messages: List[Dict[str, Any]] = field(default_factory=list)
|
|
|
|
|
|
@dataclass
|
|
class Metadata:
|
|
id: str
|
|
name: str
|
|
status: Optional[str] = None
|
|
created_at: Optional[datetime.datetime] = None
|
|
updated_at: Optional[datetime.datetime] = None
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return {
|
|
"id": self.id,
|
|
"name": self.name,
|
|
"status": self.status,
|
|
"created_at": self.created_at.isoformat() if self.created_at else None,
|
|
"updated_at": self.updated_at.isoformat() if self.updated_at else None,
|
|
}
|
|
|
|
@classmethod
|
|
def from_dict(cls, data: Dict[str, Any]) -> "Metadata":
|
|
created = data.get("created_at")
|
|
updated = data.get("updated_at")
|
|
if isinstance(created, str):
|
|
try:
|
|
created = datetime.datetime.fromisoformat(created)
|
|
except ValueError:
|
|
created = None
|
|
if isinstance(updated, str):
|
|
try:
|
|
updated = datetime.datetime.fromisoformat(updated)
|
|
except ValueError:
|
|
updated = None
|
|
return cls(
|
|
id=data["id"],
|
|
name=data.get("name", ""),
|
|
status=data.get("status"),
|
|
created_at=created,
|
|
updated_at=updated,
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class TrackState:
|
|
metadata: Metadata
|
|
discussion: List[str] = field(default_factory=list)
|
|
tasks: List[Ticket] = field(default_factory=list)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
serialized_discussion = []
|
|
for item in self.discussion:
|
|
if isinstance(item, dict):
|
|
new_item = dict(item)
|
|
if "ts" in new_item and isinstance(new_item["ts"], datetime.datetime):
|
|
new_item["ts"] = new_item["ts"].isoformat()
|
|
serialized_discussion.append(new_item)
|
|
else:
|
|
serialized_discussion.append(item)
|
|
return {
|
|
"metadata": self.metadata.to_dict(),
|
|
"discussion": serialized_discussion,
|
|
"tasks": [t.to_dict() for t in self.tasks],
|
|
}
|
|
|
|
@classmethod
|
|
def from_dict(cls, data: Dict[str, Any]) -> "TrackState":
|
|
discussion = data.get("discussion", [])
|
|
parsed_discussion = []
|
|
for item in discussion:
|
|
if isinstance(item, dict):
|
|
new_item = dict(item)
|
|
ts = new_item.get("ts")
|
|
if isinstance(ts, str):
|
|
try:
|
|
new_item["ts"] = datetime.datetime.fromisoformat(ts)
|
|
except ValueError:
|
|
pass
|
|
parsed_discussion.append(new_item)
|
|
else:
|
|
parsed_discussion.append(item)
|
|
return cls(
|
|
metadata=Metadata.from_dict(data["metadata"]),
|
|
discussion=parsed_discussion,
|
|
tasks=[Ticket.from_dict(t) for t in data.get("tasks", [])],
|
|
)
|
|
|
|
@dataclass
|
|
class FileItem:
|
|
path: str
|
|
auto_aggregate: bool = True
|
|
force_full: bool = False
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return {
|
|
"path": self.path,
|
|
"auto_aggregate": self.auto_aggregate,
|
|
"force_full": self.force_full,
|
|
}
|
|
|
|
@classmethod
|
|
def from_dict(cls, data: Dict[str, Any]) -> "FileItem":
|
|
return cls(
|
|
path=data["path"],
|
|
auto_aggregate=data.get("auto_aggregate", True),
|
|
force_full=data.get("force_full", False),
|
|
)
|