devcouncil 0.1.0 → 0.2.0

package/src/devcouncil/storage/db.py

@@ -1,66 +1,147 @@
-from contextlib import contextmanager
-
-from sqlmodel import SQLModel, create_engine, Session
-from sqlalchemy.exc import OperationalError
-from pathlib import Path
-from typing import Optional
-
-from devcouncil.storage.models import SchemaVersionModel
-
-
-SCHEMA_VERSION = 1
-
-
-class Database:
-    def __init__(self, db_path: Path):
-        self.db_path = db_path
-        self.engine = create_engine(f"sqlite:///{db_path}")
-
-    def create_db_and_tables(self):
-        self._create_tables()
-        self.ensure_schema_version()
-
-    def ensure_schema_version(self):
-        self._create_tables()
-        with Session(self.engine) as session:
-            current = session.get(SchemaVersionModel, "singleton")
-            if current is None:
-                session.add(SchemaVersionModel(id="singleton", version=SCHEMA_VERSION))
-                session.commit()
-                return
-            if current.version != SCHEMA_VERSION:
-                raise RuntimeError(
-                    f"Unsupported DevCouncil schema version {current.version}; "
-                    f"expected {SCHEMA_VERSION}."
-                )
-
-    def _create_tables(self):
-        try:
-            SQLModel.metadata.create_all(self.engine)
-        except OperationalError as exc:
-            if "already exists" not in str(exc):
-                raise
-
-    @contextmanager
-    def get_session(self):
-        """Yield a session with automatic commit/rollback/close."""
-        session = Session(self.engine)
-        try:
-            yield session
-            session.commit()
-        except Exception:
-            session.rollback()
-            raise
-        finally:
-            session.close()
-
-
-def get_db(project_root: Path = Path(".")) -> Optional[Database]:
-    dev_dir = project_root / ".devcouncil"
-    if not dev_dir.exists():
-        return None
-    
-    db_path = dev_dir / "state.sqlite"
-    db = Database(db_path)
-    db.ensure_schema_version()
-    return db
+from collections import defaultdict
+from contextlib import contextmanager
+from datetime import datetime, timezone
+
+from sqlmodel import SQLModel, create_engine, Session
+from sqlalchemy import inspect, text
+from sqlalchemy.exc import OperationalError
+from pathlib import Path
+from typing import Optional
+
+from devcouncil.storage.models import SchemaVersionModel
+
+
+# v3: per-task indexes on the task/audit tables (task_id, lease status).
+# v4: machine-routable gap columns (file, line, suggested_command,
+#     acceptance_criterion_id) so the repair contract survives a reload.
+# v5: partial unique index enforcing one ACTIVE lease per task (single-writer).
+SCHEMA_VERSION = 5
+
+
+class Database:
+    def __init__(self, db_path: Path):
+        self.db_path = db_path
+        self.engine = create_engine(f"sqlite:///{db_path}")
+
+    def create_db_and_tables(self):
+        self._create_tables()
+        self.ensure_schema_version()
+
+    def ensure_schema_version(self):
+        self._create_tables()
+        with Session(self.engine) as session:
+            current = session.get(SchemaVersionModel, "singleton")
+            if current is None:
+                session.add(SchemaVersionModel(id="singleton", version=SCHEMA_VERSION))
+                session.commit()
+                return
+            if current.version > SCHEMA_VERSION:
+                raise RuntimeError(
+                    f"Unsupported DevCouncil schema version {current.version}; "
+                    f"expected {SCHEMA_VERSION}."
+                )
+            if current.version < SCHEMA_VERSION:
+                self._create_tables()
+                current.version = SCHEMA_VERSION
+                session.add(current)
+                session.commit()
+                return
+
+    def _create_tables(self):
+        try:
+            SQLModel.metadata.create_all(self.engine)
+        except OperationalError as exc:
+            if "already exists" not in str(exc):
+                raise
+        self._create_missing_columns()
+        self._dedup_active_leases()
+        self._create_missing_indexes()
+
+    def _dedup_active_leases(self):
+        # The partial unique index (ux_task_leases_active) can only be created if no task
+        # already has two ACTIVE leases. Older databases predate the constraint, so
+        # collapse any duplicates first — keep the newest active lease per task, mark the
+        # rest stale — making index creation succeed and restoring single-writer state.
+        inspector = inspect(self.engine)
+        if "task_leases" not in inspector.get_table_names():
+            return
+        with self.engine.begin() as conn:
+            rows = conn.execute(
+                text("SELECT id, task_id, created_at FROM task_leases WHERE status = 'active'")
+            ).fetchall()
+            by_task = defaultdict(list)
+            for row in rows:
+                by_task[row.task_id].append(((row.created_at or ""), row.id))
+            stale_ids = []
+            for items in by_task.values():
+                if len(items) <= 1:
+                    continue
+                items.sort()  # ascending by (created_at, id); keep the last = newest
+                stale_ids.extend(item[1] for item in items[:-1])
+            if stale_ids:
+                now = datetime.now(timezone.utc).isoformat()
+                for lease_id in stale_ids:
+                    conn.execute(
+                        text("UPDATE task_leases SET status = 'stale', released_at = :ts WHERE id = :id"),
+                        {"ts": now, "id": lease_id},
+                    )
+
+    def _create_missing_columns(self):
+        # create_all never alters an existing table, so columns added to a model
+        # later (e.g. the v4 gap routing columns) are missing on databases created by
+        # an older version — and a SELECT of the model would then fail. Add any
+        # missing column as a nullable ADD COLUMN (the only shape SQLite can add in
+        # place without a table rewrite); non-nullable additions are intentionally
+        # skipped because existing rows could not satisfy them.
+        inspector = inspect(self.engine)
+        existing_tables = set(inspector.get_table_names())
+        for table in SQLModel.metadata.sorted_tables:
+            if table.name not in existing_tables:
+                continue
+            existing_cols = {col["name"] for col in inspector.get_columns(table.name)}
+            for column in table.columns:
+                if column.name in existing_cols or not column.nullable:
+                    continue
+                ddl_type = column.type.compile(self.engine.dialect)
+                stmt = text(f'ALTER TABLE "{table.name}" ADD COLUMN "{column.name}" {ddl_type}')
+                try:
+                    with self.engine.begin() as conn:
+                        conn.execute(stmt)
+                except OperationalError as exc:
+                    if "duplicate column name" not in str(exc).lower():
+                        raise
+
+    def _create_missing_indexes(self):
+        # create_all skips tables that already exist, so indexes added to the
+        # model definitions later never materialize on existing databases.
+        for table in SQLModel.metadata.sorted_tables:
+            for index in table.indexes:
+                try:
+                    index.create(self.engine, checkfirst=True)
+                except OperationalError as exc:
+                    if "already exists" not in str(exc):
+                        raise
+
+    @contextmanager
+    def get_session(self):
+        """Yield a session with automatic commit/rollback/close."""
+        session = Session(self.engine)
+        try:
+            yield session
+            session.commit()
+        except Exception:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+
+def get_db(project_root: Path = Path(".")) -> Optional[Database]:
+    dev_dir = project_root / ".devcouncil"
+    if not dev_dir.exists():
+        return None
+    
+    db_path = dev_dir / "state.sqlite"
+    db = Database(db_path)
+    db.ensure_schema_version()
+    return db

package/src/devcouncil/storage/models.py

@@ -1,83 +1,204 @@
-from sqlmodel import SQLModel, Field
-from typing import Optional
-
-
-class SchemaVersionModel(SQLModel, table=True):
-    __tablename__ = "schema_version"
-    id: str = Field(primary_key=True, default="singleton")
-    version: int
-
-class RequirementModel(SQLModel, table=True):
-    __tablename__ = "requirements"
-    id: str = Field(primary_key=True)
-    title: str
-    description: str
-    priority: str
-    source: str
-    # Store complex lists as JSON strings for simplicity in SQLite
-    acceptance_criteria_json: str = Field(default="[]")
-
-class AssumptionModel(SQLModel, table=True):
-    __tablename__ = "assumptions"
-    id: str = Field(primary_key=True)
-    statement: str
-    confidence: str
-    impact: str
-    reversible: bool
-    requires_user_confirmation: bool
-    linked_requirement_ids_json: str = Field(default="[]")
-    status: str = "open"
-
-class TaskModel(SQLModel, table=True):
-    __tablename__ = "tasks"
-    id: str = Field(primary_key=True)
-    title: str
-    description: str
-    requirement_ids_json: str = Field(default="[]")
-    acceptance_criterion_ids_json: str = Field(default="[]")
-    planned_files_json: str = Field(default="[]")
-    expected_tests_json: str = Field(default="[]")
-    allowed_commands_json: str = Field(default="[]")
-    forbidden_changes_json: str = Field(default="[]")
-    status: str = "planned"
-
-class EvidenceModel(SQLModel, table=True):
-    __tablename__ = "evidence"
-    id: Optional[int] = Field(default=None, primary_key=True)
-    type: str  # "command", "diff", "test"
-    task_id: Optional[str] = None
-    requirement_id: Optional[str] = None
-    acceptance_criterion_id: Optional[str] = None
-    data_json: str
-
-class GapModel(SQLModel, table=True):
-    __tablename__ = "gaps"
-    id: str = Field(primary_key=True)
-    severity: str
-    gap_type: str
-    requirement_id: Optional[str] = None
-    task_id: Optional[str] = None
-    description: str
-    evidence_json: str = Field(default="[]")
-    recommended_fix: str
-    blocking: bool
-
-class CritiqueFindingModel(SQLModel, table=True):
-    __tablename__ = "critique_findings"
-    id: str = Field(primary_key=True)
-    source_agent: str
-    target_plan_id: str
-    severity: str
-    finding_type: str
-    claim: str
-    linked_requirement_id: Optional[str] = None
-    suggested_requirement: Optional[str] = None
-    suggested_task: Optional[str] = None
-    falsifiable_check: str
-    status: str = "open"
-
-class ProjectStateModel(SQLModel, table=True):
-    __tablename__ = "project_state"
-    id: str = Field(primary_key=True, default="singleton")
-    current_phase: str
-    history_json: str = Field(default="[]")
+from sqlmodel import SQLModel, Field
+from sqlalchemy import Index, text
+from typing import Optional
+
+
+class SchemaVersionModel(SQLModel, table=True):
+    __tablename__ = "schema_version"
+    id: str = Field(primary_key=True, default="singleton")
+    version: int
+
+class RequirementModel(SQLModel, table=True):
+    __tablename__ = "requirements"
+    id: str = Field(primary_key=True)
+    title: str
+    description: str
+    priority: str
+    source: str
+    # Store complex lists as JSON strings for simplicity in SQLite
+    acceptance_criteria_json: str = Field(default="[]")
+
+class AssumptionModel(SQLModel, table=True):
+    __tablename__ = "assumptions"
+    id: str = Field(primary_key=True)
+    statement: str
+    confidence: str
+    impact: str
+    reversible: bool
+    requires_user_confirmation: bool
+    linked_requirement_ids_json: str = Field(default="[]")
+    status: str = "open"
+
+class TaskModel(SQLModel, table=True):
+    __tablename__ = "tasks"
+    id: str = Field(primary_key=True)
+    title: str
+    description: str
+    requirement_ids_json: str = Field(default="[]")
+    acceptance_criterion_ids_json: str = Field(default="[]")
+    planned_files_json: str = Field(default="[]")
+    expected_tests_json: str = Field(default="[]")
+    allowed_commands_json: str = Field(default="[]")
+    forbidden_changes_json: str = Field(default="[]")
+    status: str = "planned"
+
+class EvidenceModel(SQLModel, table=True):
+    __tablename__ = "evidence"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    type: str  # "command", "diff", "test"
+    task_id: Optional[str] = None
+    requirement_id: Optional[str] = None
+    acceptance_criterion_id: Optional[str] = None
+    data_json: str
+
+class GapModel(SQLModel, table=True):
+    __tablename__ = "gaps"
+    id: str = Field(primary_key=True)
+    severity: str
+    gap_type: str
+    requirement_id: Optional[str] = None
+    task_id: Optional[str] = None
+    description: str
+    evidence_json: str = Field(default="[]")
+    recommended_fix: str
+    blocking: bool
+    # Machine-routable repair hints. Persisted (v4) so the typed next-actions
+    # contract survives a reload — a reconnecting/crashed agent can read outstanding
+    # gaps without the heuristic reconstruction the loader used to fall back to.
+    file: Optional[str] = None
+    line: Optional[int] = None
+    suggested_command: Optional[str] = None
+    acceptance_criterion_id: Optional[str] = None
+
+class CritiqueFindingModel(SQLModel, table=True):
+    __tablename__ = "critique_findings"
+    id: str = Field(primary_key=True)
+    source_agent: str
+    target_plan_id: str
+    severity: str
+    finding_type: str
+    claim: str
+    linked_requirement_id: Optional[str] = None
+    suggested_requirement: Optional[str] = None
+    suggested_task: Optional[str] = None
+    falsifiable_check: str
+    status: str = "open"
+
+class ProjectStateModel(SQLModel, table=True):
+    __tablename__ = "project_state"
+    id: str = Field(primary_key=True, default="singleton")
+    current_phase: str
+    history_json: str = Field(default="[]")
+
+
+class TaskLeaseModel(SQLModel, table=True):
+    __tablename__ = "task_leases"
+    # Enforce the single-writer guarantee at the DB level: at most one ACTIVE lease per
+    # task. A partial unique index turns a concurrent double-checkout race into an
+    # IntegrityError (surfaced as lease_conflict) instead of two live leases.
+    __table_args__ = (
+        Index(
+            "ux_task_leases_active",
+            "task_id",
+            unique=True,
+            sqlite_where=text("status = 'active'"),
+        ),
+    )
+    id: str = Field(primary_key=True)
+    task_id: str = Field(index=True)
+    owner: str
+    agent: Optional[str] = None
+    client_id: Optional[str] = None
+    run_id: Optional[str] = None
+    branch: Optional[str] = None
+    lease_token: str
+    status: str = Field(default="active", index=True)
+    created_at: str
+    expires_at: Optional[str] = None
+    released_at: Optional[str] = None
+
+
+class ShellSessionModel(SQLModel, table=True):
+    __tablename__ = "shell_sessions"
+    id: str = Field(primary_key=True)
+    task_id: str = Field(index=True)
+    lease_id: Optional[str] = None
+    shell: str
+    cwd: str
+    status: str
+    started_at: str
+    ended_at: Optional[str] = None
+
+
+class ShellCommandEventModel(SQLModel, table=True):
+    __tablename__ = "shell_command_events"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    task_id: str = Field(index=True)
+    session_id: Optional[str] = None
+    command: str
+    status: str
+    exit_code: Optional[int] = None
+    reason: str = ""
+    stdout_path: str = ""
+    stderr_path: str = ""
+    created_at: str
+
+
+class FileChangeEventModel(SQLModel, table=True):
+    __tablename__ = "file_change_events"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    task_id: Optional[str] = Field(default=None, index=True)
+    lease_id: Optional[str] = None
+    session_id: Optional[str] = None
+    path: str
+    operation: str
+    allowed: bool
+    reason: str = ""
+    created_at: str
+
+
+class SemanticDiffModel(SQLModel, table=True):
+    __tablename__ = "semantic_diffs"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    task_id: str = Field(index=True)
+    before_snapshot_path: str
+    after_snapshot_path: str
+    classifications_json: str = "[]"
+    summary: str = ""
+    created_at: str
+
+
+class AgentHandoffModel(SQLModel, table=True):
+    __tablename__ = "agent_handoffs"
+    id: str = Field(primary_key=True)
+    task_id: str = Field(index=True)
+    from_agent: str
+    to_agent: str
+    run_id: str
+    manifest_path: str
+    status: str
+    created_at: str
+
+
+class CorrectionManifestModel(SQLModel, table=True):
+    __tablename__ = "correction_manifests"
+    id: str = Field(primary_key=True)
+    task_id: str = Field(index=True)
+    run_id: Optional[str] = None
+    manifest_path: str
+    retry_budget: int = 3
+    attempt: int = 0
+    status: str
+    created_at: str
+
+
+class VerificationRunModel(SQLModel, table=True):
+    __tablename__ = "verification_runs"
+    id: str = Field(primary_key=True)
+    task_id: str = Field(index=True)
+    sandbox: str
+    environment_json: str = "{}"
+    commands_json: str = "[]"
+    status: str
+    started_at: str
+    finished_at: Optional[str] = None