devmemory-cli 0.1.0.dev0__py3-none-any.whl

devmemory/storage/migrations/0002_versions.sql

@@ -0,0 +1,210 @@
+-- 0002_versions: the development-version record and everything hanging off it.
+--
+-- Facts (git, entire, tests, metrics) and AI analysis are kept in separate
+-- tables. A version can reference more than one Entire checkpoint.
+
+CREATE TABLE versions (
+    version_number   INTEGER NOT NULL,
+    version_id       TEXT PRIMARY KEY,              -- "v7"
+    project_id       TEXT NOT NULL,
+
+    intent           TEXT,
+    agent            TEXT,
+    model            TEXT,
+
+    git_commit       TEXT NOT NULL,
+    parent_commit    TEXT,
+    branch           TEXT,
+
+    feature_id       TEXT,
+    status           TEXT NOT NULL,
+
+    files_changed    INTEGER NOT NULL DEFAULT 0,
+    lines_added      INTEGER NOT NULL DEFAULT 0,
+    lines_removed    INTEGER NOT NULL DEFAULT 0,
+
+    entire_association_method     TEXT,
+    entire_association_confidence REAL,
+
+    environment_json TEXT,
+    source_event_json TEXT,
+    run_id           TEXT,
+
+    created_at       TEXT NOT NULL,                 -- when DevMemory recorded it
+    committed_at     TEXT,                          -- the git commit's own time
+
+    UNIQUE (project_id, version_number),
+    UNIQUE (project_id, git_commit),
+    FOREIGN KEY (project_id) REFERENCES projects(project_id),
+    FOREIGN KEY (feature_id) REFERENCES features(feature_id)
+);
+
+CREATE TABLE entire_checkpoints (
+    checkpoint_id          TEXT PRIMARY KEY,
+    project_id             TEXT NOT NULL,
+    ref                    TEXT,
+    agent                  TEXT,
+    model                  TEXT,
+    intent                 TEXT,
+    strategy               TEXT,
+    created_at             TEXT,
+    git_commit             TEXT,
+    association_method     TEXT,
+    association_confidence REAL,
+    tokens_json            TEXT,
+    imported               INTEGER NOT NULL DEFAULT 0,
+    sessions_json          TEXT,
+    FOREIGN KEY (project_id) REFERENCES projects(project_id)
+);
+
+CREATE TABLE version_checkpoints (
+    version_id    TEXT NOT NULL,
+    checkpoint_id TEXT NOT NULL,
+    is_primary    INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (version_id, checkpoint_id),
+    FOREIGN KEY (version_id) REFERENCES versions(version_id) ON DELETE CASCADE,
+    FOREIGN KEY (checkpoint_id) REFERENCES entire_checkpoints(checkpoint_id)
+);
+
+CREATE TABLE changed_files (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    version_id    TEXT NOT NULL,
+    path          TEXT NOT NULL,
+    old_path      TEXT,
+    change_type   TEXT NOT NULL,
+    additions     INTEGER NOT NULL DEFAULT 0,
+    deletions     INTEGER NOT NULL DEFAULT 0,
+    binary        INTEGER NOT NULL DEFAULT 0,
+    FOREIGN KEY (version_id) REFERENCES versions(version_id) ON DELETE CASCADE
+);
+
+CREATE TABLE features (
+    feature_id   TEXT PRIMARY KEY,
+    project_id   TEXT NOT NULL,
+    name         TEXT NOT NULL,
+    status       TEXT NOT NULL,
+    derived_from TEXT,
+    created_at   TEXT NOT NULL,
+    updated_at   TEXT NOT NULL,
+    UNIQUE (project_id, name),
+    FOREIGN KEY (project_id) REFERENCES projects(project_id)
+);
+
+CREATE TABLE tests (
+    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+    version_id       TEXT NOT NULL,
+    command          TEXT,
+    framework        TEXT,
+    total            INTEGER NOT NULL DEFAULT 0,
+    passed           INTEGER NOT NULL DEFAULT 0,
+    failed           INTEGER NOT NULL DEFAULT 0,
+    skipped          INTEGER NOT NULL DEFAULT 0,
+    errors           INTEGER NOT NULL DEFAULT 0,
+    exit_code        INTEGER,
+    duration_seconds REAL,
+    failing_json     TEXT,
+    output           TEXT,
+    collected_at     TEXT,
+    FOREIGN KEY (version_id) REFERENCES versions(version_id) ON DELETE CASCADE
+);
+
+CREATE TABLE metrics (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    version_id    TEXT NOT NULL,
+    name          TEXT NOT NULL,
+    before_value  REAL,
+    after_value   REAL,
+    unit          TEXT,
+    direction     TEXT,
+    metadata_json TEXT,
+    FOREIGN KEY (version_id) REFERENCES versions(version_id) ON DELETE CASCADE
+);
+
+CREATE TABLE regressions (
+    id             INTEGER PRIMARY KEY AUTOINCREMENT,
+    version_id     TEXT NOT NULL,
+    kind           TEXT NOT NULL,          -- 'metric' | 'test'
+    metric         TEXT,
+    before_value   REAL,
+    after_value    REAL,
+    change_percent REAL,
+    severity       TEXT NOT NULL,          -- 'LOW' | 'MEDIUM' | 'HIGH'
+    detail         TEXT,
+    FOREIGN KEY (version_id) REFERENCES versions(version_id) ON DELETE CASCADE
+);
+
+CREATE TABLE analysis (
+    version_id     TEXT PRIMARY KEY,
+    summary        TEXT,
+    reasoning      TEXT,
+    recommendation TEXT,
+    warnings_json  TEXT,
+    risk           TEXT,
+    provider       TEXT NOT NULL,          -- 'rules' | 'anthropic' | ...
+    model          TEXT,
+    generated_at   TEXT NOT NULL,
+    FOREIGN KEY (version_id) REFERENCES versions(version_id) ON DELETE CASCADE
+);
+
+CREATE TABLE artifacts (
+    artifact_id  TEXT PRIMARY KEY,
+    version_id   TEXT NOT NULL,
+    path         TEXT NOT NULL,
+    type         TEXT NOT NULL,
+    size_bytes   INTEGER,
+    sha256       TEXT,
+    created_at   TEXT NOT NULL,
+    FOREIGN KEY (version_id) REFERENCES versions(version_id) ON DELETE CASCADE
+);
+
+CREATE TABLE doc_flags (
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    version_id TEXT NOT NULL,
+    doc_path   TEXT NOT NULL,
+    reason     TEXT,
+    FOREIGN KEY (version_id) REFERENCES versions(version_id) ON DELETE CASCADE
+);
+
+CREATE TABLE events (
+    event_id     TEXT PRIMARY KEY,
+    project_id   TEXT NOT NULL,
+    version_id   TEXT,
+    type         TEXT NOT NULL,
+    source       TEXT NOT NULL DEFAULT 'devmemory',
+    payload_json TEXT,
+    created_at   TEXT NOT NULL,
+    FOREIGN KEY (project_id) REFERENCES projects(project_id)
+);
+
+CREATE INDEX idx_versions_project        ON versions(project_id, version_number);
+CREATE INDEX idx_versions_git_commit     ON versions(git_commit);
+CREATE INDEX idx_versions_feature        ON versions(feature_id);
+CREATE INDEX idx_versions_status         ON versions(status);
+CREATE INDEX idx_changed_files_version   ON changed_files(version_id);
+CREATE INDEX idx_changed_files_path      ON changed_files(path);
+CREATE INDEX idx_metrics_version         ON metrics(version_id);
+CREATE INDEX idx_metrics_name            ON metrics(name);
+CREATE INDEX idx_tests_version           ON tests(version_id);
+CREATE INDEX idx_regressions_version     ON regressions(version_id);
+CREATE INDEX idx_checkpoints_project     ON entire_checkpoints(project_id);
+CREATE INDEX idx_checkpoints_commit      ON entire_checkpoints(git_commit);
+CREATE INDEX idx_version_checkpoints_cp  ON version_checkpoints(checkpoint_id);
+CREATE INDEX idx_events_version          ON events(version_id);
+
+-- Full-text search over normalized version metadata. Plain (not external-content)
+-- FTS5 - the version repository keeps it in sync explicitly on write/delete.
+CREATE VIRTUAL TABLE version_search USING fts5 (
+    version_id UNINDEXED,
+    intent,
+    feature,
+    agent,
+    model,
+    status,
+    files,
+    commit_sha,
+    checkpoint_id,
+    analysis,
+    recommendation,
+    errors,
+    tokenize = 'unicode61 remove_diacritics 2'
+);

devmemory/storage/migrations/0003_graph.sql

@@ -0,0 +1,14 @@
+-- Phase 12: change-impact analysis from the Entire `graph` plugin.
+-- One row per version. `payload` is the full GraphImpact JSON; the summary
+-- columns are denormalized for cheap listing. Local-only telemetry - never
+-- published to Databricks.
+
+CREATE TABLE graph_impacts (
+    version_id      TEXT PRIMARY KEY REFERENCES versions(version_id) ON DELETE CASCADE,
+    base_commit     TEXT NOT NULL DEFAULT '',
+    head_commit     TEXT NOT NULL DEFAULT '',
+    entity_count    INTEGER NOT NULL DEFAULT 0,
+    max_dependents  INTEGER NOT NULL DEFAULT 0,
+    generated_at    TEXT NOT NULL,
+    payload         TEXT NOT NULL
+);

devmemory/storage/migrations/0004_taskloop.sql

@@ -0,0 +1,82 @@
+-- 0004_taskloop: the state-aware coding loop.
+--
+-- A task is a live, multi-commit unit of work with an explicit requirement list.
+-- Every refresh_state appends one immutable row to state_snapshots, so the loop
+-- is observable as snapshot #1 -> #2 -> #3. Nothing here stores application code
+-- or full transcripts.
+
+CREATE TABLE tasks (
+    id            TEXT PRIMARY KEY,               -- "TASK-001"
+    goal          TEXT NOT NULL,                  -- the human task, verbatim
+    status        TEXT NOT NULL DEFAULT 'IN_PROGRESS',
+    branch        TEXT NOT NULL DEFAULT 'main',
+    base_commit   TEXT,                           -- HEAD when the task was created
+    test_command  TEXT,
+    push_policy   TEXT NOT NULL DEFAULT 'manual',
+    created_at    TEXT NOT NULL,
+    updated_at    TEXT NOT NULL
+);
+
+CREATE TABLE requirements (
+    task_id       TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    req_id        TEXT NOT NULL,                  -- "R1"
+    description   TEXT NOT NULL,
+    status        TEXT NOT NULL DEFAULT 'INCOMPLETE',
+    reason        TEXT NOT NULL DEFAULT '',
+    evidence_json TEXT NOT NULL DEFAULT '[]',
+    evaluated_at  TEXT,
+    evaluated_by  TEXT NOT NULL DEFAULT '',
+    position      INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (task_id, req_id)
+);
+
+CREATE TABLE issues (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id       TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    description   TEXT NOT NULL,
+    kind          TEXT NOT NULL DEFAULT 'agent',   -- agent | test | requirement | engine
+    blocking      INTEGER NOT NULL DEFAULT 0,
+    status        TEXT NOT NULL DEFAULT 'OPEN',    -- OPEN | RESOLVED
+    created_at    TEXT NOT NULL,
+    resolved_at   TEXT
+);
+
+CREATE INDEX idx_issues_task ON issues(task_id, status);
+
+CREATE TABLE task_test_runs (
+    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id          TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    command          TEXT NOT NULL,
+    status           TEXT NOT NULL,               -- NOT_RUN | PASSED | FAILED | FAILED_TO_PARSE | ERROR
+    passed           INTEGER NOT NULL DEFAULT 0,
+    failed           INTEGER NOT NULL DEFAULT 0,
+    skipped          INTEGER NOT NULL DEFAULT 0,
+    exit_code        INTEGER,
+    duration_seconds REAL,
+    output_path      TEXT,
+    created_at       TEXT NOT NULL
+);
+
+CREATE INDEX idx_test_runs_task ON task_test_runs(task_id, created_at);
+
+-- The most important table: one immutable snapshot per refresh_state.
+CREATE TABLE state_snapshots (
+    id             INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id        TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    overall_status TEXT NOT NULL,
+    commit_sha     TEXT,
+    checkpoint_id  TEXT,
+    state_json     TEXT NOT NULL,                 -- the full NormalizedState
+    created_at     TEXT NOT NULL
+);
+
+CREATE INDEX idx_snapshots_task ON state_snapshots(task_id, created_at);
+
+-- Optional: link versions produced under a task (the existing versions table is
+-- untouched; this is a side index).
+CREATE TABLE task_commits (
+    task_id     TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    commit_sha  TEXT NOT NULL,
+    created_at  TEXT NOT NULL,
+    PRIMARY KEY (task_id, commit_sha)
+);

devmemory/storage/migrations/0005_project_brief.sql

@@ -0,0 +1,12 @@
+-- 0005_project_brief: the project's single source of truth.
+--
+-- One editable document (specs, constraints, decisions, conventions) the human
+-- uploads or pastes. It is fed into requirement normalization and the prompt
+-- suggestions so the loop stays anchored to what the project is actually for.
+-- One row, id = 1.
+
+CREATE TABLE project_brief (
+    id          INTEGER PRIMARY KEY CHECK (id = 1),
+    content     TEXT NOT NULL DEFAULT '',
+    updated_at  TEXT NOT NULL
+);

devmemory/storage/repositories.py

@@ -0,0 +1,286 @@
+"""Data-access objects. Every SQL statement in DevMemory lives in this module.
+
+Repositories take a :class:`~devmemory.storage.db.Database` and expose typed
+methods returning :mod:`devmemory.domain.models`. Services depend on repositories;
+nothing else touches the connection.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import UTC, datetime
+
+from devmemory.domain.enums import AssociationMethod, FeatureStatus
+from devmemory.domain.models import (
+    CheckpointReference,
+    CheckpointSession,
+    Feature,
+    Project,
+    TokenUsage,
+)
+from devmemory.storage.db import Database
+
+
+def _utcnow() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def _dt(value: str | None) -> datetime | None:
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(value)
+    except ValueError:
+        return None
+
+
+def _json_or_none(value: object) -> str | None:
+    return json.dumps(value) if value is not None else None
+
+
+def _load_json(value: str | None) -> object:
+    if not value:
+        return None
+    try:
+        return json.loads(value)
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+
+# --- projects -----------------------------------------------------------------------
+
+
+class ProjectRepository:
+    def __init__(self, db: Database) -> None:
+        self._db = db
+
+    def get(self) -> Project | None:
+        row = self._db.query_one("SELECT * FROM projects LIMIT 1")
+        return _project_from_row(row) if row else None
+
+    def get_by_id(self, project_id: str) -> Project | None:
+        row = self._db.query_one("SELECT * FROM projects WHERE project_id = ?", (project_id,))
+        return _project_from_row(row) if row else None
+
+    def create(self, *, project_id: str, name: str, repo_path: str) -> Project:
+        now = _utcnow()
+        try:
+            with self._db.transaction() as conn:
+                conn.execute(
+                    "INSERT INTO projects (project_id, name, repo_path, created_at, updated_at) "
+                    "VALUES (?, ?, ?, ?, ?)",
+                    (project_id, name, repo_path, now, now),
+                )
+        except sqlite3.IntegrityError as exc:
+            raise ValueError(f"project {project_id!r} already exists") from exc
+        created = self.get_by_id(project_id)
+        assert created is not None  # noqa: S101 - just inserted
+        return created
+
+    def set_current_version(self, project_id: str, version_id: int | None) -> None:
+        with self._db.transaction() as conn:
+            conn.execute(
+                "UPDATE projects SET current_version_id = ?, updated_at = ? WHERE project_id = ?",
+                (version_id, _utcnow(), project_id),
+            )
+
+    def touch(self, project_id: str) -> None:
+        with self._db.transaction() as conn:
+            conn.execute(
+                "UPDATE projects SET updated_at = ? WHERE project_id = ?",
+                (_utcnow(), project_id),
+            )
+
+
+def _project_from_row(row: sqlite3.Row) -> Project:
+    return Project(
+        project_id=row["project_id"],
+        name=row["name"],
+        repo_path=row["repo_path"],
+        created_at=datetime.fromisoformat(row["created_at"]),
+        updated_at=datetime.fromisoformat(row["updated_at"]),
+        current_version_id=row["current_version_id"],
+    )
+
+
+# --- entire checkpoints ------------------------------------------------------------
+
+
+class CheckpointRepository:
+    def __init__(self, db: Database) -> None:
+        self._db = db
+
+    def upsert(self, project_id: str, ref: CheckpointReference) -> None:
+        with self._db.transaction() as conn:
+            conn.execute(
+                """
+                INSERT INTO entire_checkpoints (
+                    checkpoint_id, project_id, ref, agent, model, intent, strategy,
+                    created_at, git_commit, association_method, association_confidence,
+                    tokens_json, imported, sessions_json
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(checkpoint_id) DO UPDATE SET
+                    ref = COALESCE(excluded.ref, entire_checkpoints.ref),
+                    agent = COALESCE(excluded.agent, entire_checkpoints.agent),
+                    model = COALESCE(excluded.model, entire_checkpoints.model),
+                    intent = COALESCE(excluded.intent, entire_checkpoints.intent),
+                    strategy = COALESCE(excluded.strategy, entire_checkpoints.strategy),
+                    created_at = COALESCE(excluded.created_at, entire_checkpoints.created_at),
+                    git_commit = COALESCE(excluded.git_commit, entire_checkpoints.git_commit),
+                    association_method = excluded.association_method,
+                    association_confidence = excluded.association_confidence,
+                    tokens_json = excluded.tokens_json,
+                    imported = excluded.imported,
+                    sessions_json = excluded.sessions_json
+                """,
+                (
+                    ref.checkpoint_id,
+                    project_id,
+                    ref.ref,
+                    ref.agent,
+                    ref.model,
+                    ref.intent,
+                    ref.strategy,
+                    ref.created_at.isoformat() if ref.created_at else None,
+                    ref.commit_sha,
+                    ref.association_method.value,
+                    ref.association_confidence,
+                    json.dumps(ref.tokens.model_dump()),
+                    1 if ref.imported else 0,
+                    json.dumps([s.model_dump(mode="json") for s in ref.sessions]),
+                ),
+            )
+
+    def get(self, checkpoint_id: str) -> CheckpointReference | None:
+        row = self._db.query_one(
+            "SELECT * FROM entire_checkpoints WHERE checkpoint_id = ?", (checkpoint_id,)
+        )
+        return _checkpoint_from_row(row) if row else None
+
+    def link(self, version_id: str, checkpoint_id: str, *, is_primary: bool) -> None:
+        with self._db.transaction() as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO version_checkpoints (version_id, checkpoint_id, is_primary) "
+                "VALUES (?, ?, ?)",
+                (version_id, checkpoint_id, 1 if is_primary else 0),
+            )
+
+    def for_version(self, version_id: str) -> list[tuple[CheckpointReference, bool]]:
+        rows = self._db.query(
+            """
+            SELECT c.*, vc.is_primary FROM entire_checkpoints c
+            JOIN version_checkpoints vc ON vc.checkpoint_id = c.checkpoint_id
+            WHERE vc.version_id = ?
+            ORDER BY vc.is_primary DESC
+            """,
+            (version_id,),
+        )
+        return [(_checkpoint_from_row(r), bool(r["is_primary"])) for r in rows]
+
+
+def _checkpoint_from_row(row: sqlite3.Row) -> CheckpointReference:
+    tokens_raw = _load_json(row["tokens_json"])
+    sessions_raw = _load_json(row["sessions_json"])
+    method_value = row["association_method"] or AssociationMethod.NONE.value
+    return CheckpointReference(
+        checkpoint_id=row["checkpoint_id"],
+        commit_sha=row["git_commit"],
+        intent=row["intent"],
+        agent=row["agent"],
+        model=row["model"],
+        strategy=row["strategy"],
+        created_at=_dt(row["created_at"]),
+        sessions=[CheckpointSession.model_validate(s) for s in sessions_raw]
+        if isinstance(sessions_raw, list)
+        else [],
+        tokens=TokenUsage.model_validate(tokens_raw)
+        if isinstance(tokens_raw, dict)
+        else TokenUsage(),
+        association_method=AssociationMethod(method_value),
+        association_confidence=row["association_confidence"] or 0.0,
+        ref=row["ref"],
+        imported=bool(row["imported"]),
+    )
+
+
+# --- features ---------------------------------------------------------------------
+
+
+class FeatureRepository:
+    def __init__(self, db: Database) -> None:
+        self._db = db
+
+    def upsert(
+        self,
+        project_id: str,
+        name: str,
+        *,
+        status: FeatureStatus,
+        derived_from: str | None = None,
+    ) -> Feature:
+        now = _utcnow()
+        with self._db.transaction() as conn:
+            conn.execute(
+                """
+                INSERT INTO features (feature_id, project_id, name, status, derived_from,
+                                      created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(project_id, name) DO UPDATE SET
+                    status = excluded.status,
+                    derived_from = COALESCE(excluded.derived_from, features.derived_from),
+                    updated_at = excluded.updated_at
+                """,
+                (
+                    _feature_id(project_id, name),
+                    project_id,
+                    name,
+                    status.value,
+                    derived_from,
+                    now,
+                    now,
+                ),
+            )
+        feature = self.get_by_name(project_id, name)
+        assert feature is not None  # noqa: S101
+        return feature
+
+    def get_by_name(self, project_id: str, name: str) -> Feature | None:
+        row = self._db.query_one(
+            "SELECT * FROM features WHERE project_id = ? AND name = ?", (project_id, name)
+        )
+        return _feature_from_row(row) if row else None
+
+    def get(self, feature_id: str) -> Feature | None:
+        row = self._db.query_one("SELECT * FROM features WHERE feature_id = ?", (feature_id,))
+        return _feature_from_row(row) if row else None
+
+    def list_all(self, project_id: str) -> list[Feature]:
+        rows = self._db.query(
+            "SELECT * FROM features WHERE project_id = ? ORDER BY name", (project_id,)
+        )
+        return [_feature_from_row(r) for r in rows]
+
+
+def _feature_id(project_id: str, name: str) -> str:
+    slug = "".join(c if c.isalnum() else "-" for c in name.lower()).strip("-") or "feature"
+    return f"{project_id}:{slug}"
+
+
+def _feature_from_row(row: sqlite3.Row) -> Feature:
+    return Feature(
+        feature_id=row["feature_id"],
+        project_id=row["project_id"],
+        name=row["name"],
+        status=FeatureStatus(row["status"]),
+        derived_from=row["derived_from"],
+        created_at=_dt(row["created_at"]),
+        updated_at=_dt(row["updated_at"]),
+    )
+
+
+__all__ = [
+    "CheckpointRepository",
+    "FeatureRepository",
+    "ProjectRepository",
+]