diary-docs 0.1.0__py3-none-any.whl

diary/sync/__init__.py

@@ -0,0 +1,33 @@
+"""DIARY sync package — change detection, agent protocol, and git-backed sync logic."""
+
+from diary.sync.detector import (
+    ChangeType,
+    DetectedChange,
+    detect_code_changes,
+    detect_doc_changes,
+    classify_changes,
+)
+from diary.sync.protocol import (
+    SyncReport,
+    SyncStats,
+    ChangeEntry,
+    ConflictEntry,
+    serialize_report,
+    parse_report,
+    get_ai_update_prompt,
+)
+
+__all__ = [
+    "ChangeType",
+    "DetectedChange",
+    "detect_code_changes",
+    "detect_doc_changes",
+    "classify_changes",
+    "SyncReport",
+    "SyncStats",
+    "ChangeEntry",
+    "ConflictEntry",
+    "serialize_report",
+    "parse_report",
+    "get_ai_update_prompt",
+]

diary/sync/detector.py

@@ -0,0 +1,405 @@
+"""Change detection pipeline for workspace code and docs.
+
+Detects what changed, how it changed, and which AIMB blocks are affected.
+v1 uses SHA-256 only — no AST/Symbol comparison.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+import subprocess
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from diary.aimb.hasher import compute_block_hash
+from diary.aimb.parser import parse_aimb_blocks
+from diary.git_utils import get_git_diff
+
+# ---------------------------------------------------------------------------
+# Types
+# ---------------------------------------------------------------------------
+
+
+class ChangeType(Enum):
+    """Classification of a detected change."""
+
+    UNCHANGED = "unchanged"
+    CODE_CHANGED = "code_changed"
+    DOC_CHANGED_MANUALLY = "doc_changed_manually"
+    AIMB_BLOCK_CHANGED = "aimb_block_changed"
+    NEW_FILE = "new_file"
+    DELETED_FILE = "deleted_file"
+
+
+@dataclass
+class DetectedChange:
+    """A single change detected during the workspace scan.
+
+    Attributes
+    ----------
+    file_path : str
+        Path relative to the workspace root (forward-slash separated).
+    change_type : ChangeType
+        What kind of change was detected.
+    affected_aimb_blocks : list[str]
+        IDs of AIMB blocks whose content hash changed. Empty for most
+        non-doc change types.
+    confidence : float
+        How certain the detector is about this classification (0.0 – 1.0).
+    """
+
+    file_path: str
+    change_type: ChangeType
+    affected_aimb_blocks: list[str] = field(default_factory=list)
+    confidence: float = 1.0
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _sha256(content: str) -> str:
+    """Return hex-encoded SHA-256 digest of *content*."""
+    return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+
+def _read_file_or_empty(path: Path) -> str:
+    """Read a text file, returning ``""`` on any error."""
+    try:
+        return path.read_text(encoding="utf-8")
+    except (FileNotFoundError, OSError):
+        return ""
+
+
+def _git_show(workspace_path: Path, file_path: str) -> str:
+    """Return the committed content of *file_path* at HEAD.
+
+    Returns empty string if the file is not tracked in git or on error.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "show", f"HEAD:{file_path}"],
+            capture_output=True,
+            text=True,
+            cwd=str(workspace_path),
+        )
+        if result.returncode == 0:
+            return result.stdout
+    except (FileNotFoundError, OSError):
+        pass
+    return ""
+
+
+def _strip_aimb_blocks(content: str) -> str:
+    """Remove all AIMB block tags and their content from *content*.
+
+    Returns the remainder (text outside AIMB blocks).
+    """
+    # Matches: <!-- ai-managed id="..." hash="..." updated="..." --> ... <!-- /ai-managed -->
+    block_re = re.compile(
+        r"<!--\s*ai-managed\s+"
+        r'id="[^"]*"\s+'
+        r'hash="[^"]*"\s+'
+        r'updated="[^"]*"\s*'
+        r"-->\s*\n?"
+        r".*?"
+        r"<!--\s*/ai-managed\s*-->",
+        re.DOTALL,
+    )
+    return block_re.sub("", content).strip()
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def detect_code_changes(workspace: Path, index_db: Any) -> list[DetectedChange]:
+    """Detect source-code changes by comparing working tree with indexed state.
+
+    Uses ``get_git_diff()`` to enumerate changed files, then cross-references
+    each file's current SHA-256 digest against the hash stored in the index
+    database's ``hashes`` table.
+
+    Parameters
+    ----------
+    workspace : Path
+        Repository root directory.
+    index_db : Any
+        An open :class:`~diary.indexer.database.IndexDatabase` instance.
+        Its ``conn`` attribute is queried for stored hashes.
+
+    Returns
+    -------
+    list[DetectedChange]
+        One entry per changed file. Unchanged files are omitted.
+    """
+    changes: list[DetectedChange] = []
+    git_changes = get_git_diff(workspace)
+
+    for entry in git_changes:
+        status = entry["status"]
+        path = entry["path"]
+
+        # --- Deleted file ---
+        if status == "D":
+            changes.append(
+                DetectedChange(
+                    file_path=path,
+                    change_type=ChangeType.DELETED_FILE,
+                    confidence=1.0,
+                )
+            )
+            continue
+
+        full_path = workspace / path
+
+        # File disappeared between diff and now
+        if not full_path.is_file():
+            changes.append(
+                DetectedChange(
+                    file_path=path,
+                    change_type=ChangeType.DELETED_FILE,
+                    confidence=1.0,
+                )
+            )
+            continue
+
+        # Compute current SHA-256
+        content = _read_file_or_empty(full_path)
+        current_hash = _sha256(content)
+
+        # Look up stored hash from the index database
+        cur = index_db.conn.execute(
+            "SELECT sha256 FROM hashes WHERE path = ?",
+            (path,),
+        )
+        row = cur.fetchone()
+
+        if row is None:
+            # File not yet indexed — treat as new
+            changes.append(
+                DetectedChange(
+                    file_path=path,
+                    change_type=ChangeType.NEW_FILE,
+                    confidence=1.0,
+                )
+            )
+        elif row[0] != current_hash:
+            # Hash mismatch → file modified since last index
+            changes.append(
+                DetectedChange(
+                    file_path=path,
+                    change_type=ChangeType.CODE_CHANGED,
+                    confidence=1.0,
+                )
+            )
+
+    return changes
+
+
+def detect_doc_changes(workspace: Path) -> list[DetectedChange]:
+    """Detect documentation changes by comparing working tree against git HEAD.
+
+    Walks all ``.md`` files tracked by git (plus any new ``.md`` files on
+    disk under ``docs/``), parses AIMB blocks, and compares block hashes
+    between the committed and working-tree versions.
+
+    Classification rules
+    --------------------
+    * ``AIMB_BLOCK_CHANGED`` — at least one AIMB block hash differs.
+    * ``DOC_CHANGED_MANUALLY`` — file content changed but no AIMB block
+      hash differs (manual edits outside AIMB regions).
+    * ``NEW_FILE`` — file exists on disk but is not tracked in git HEAD.
+    * ``DELETED_FILE`` — file tracked in git but missing from disk.
+
+    Parameters
+    ----------
+    workspace : Path
+        Repository root directory.
+
+    Returns
+    -------
+    list[DetectedChange]
+        One entry per changed doc file. Unchanged files are omitted.
+    """
+    changes: list[DetectedChange] = []
+    workspace_str = str(workspace)
+
+    # --- Collect candidate .md files ---
+    # Start with git-tracked .md files (includes all tracked locations)
+    candidate_rel_paths: set[str] = set()
+
+    try:
+        result = subprocess.run(
+            ["git", "ls-files", "*.md"],
+            capture_output=True,
+            text=True,
+            cwd=workspace_str,
+        )
+        if result.returncode == 0:
+            for line in result.stdout.strip().splitlines():
+                line = line.strip()
+                if line:
+                    candidate_rel_paths.add(line)
+    except (FileNotFoundError, OSError):
+        pass
+
+    # Also walk docs/ on disk for untracked / new files
+    docs_dir = workspace / "docs"
+    if docs_dir.is_dir():
+        for p in docs_dir.rglob("*.md"):
+            if p.is_file():
+                try:
+                    rel = p.relative_to(workspace).as_posix()
+                    candidate_rel_paths.add(rel)
+                except ValueError:
+                    pass
+
+    if not candidate_rel_paths:
+        return changes
+
+    # --- Inspect each candidate ---
+    for rel_path in sorted(candidate_rel_paths):
+        full_path = workspace / rel_path
+        current = _read_file_or_empty(full_path)
+        baseline = _git_show(workspace, rel_path)
+
+        # Deleted from working tree but tracked in git
+        if not current and baseline:
+            changes.append(
+                DetectedChange(
+                    file_path=rel_path,
+                    change_type=ChangeType.DELETED_FILE,
+                    confidence=1.0,
+                )
+            )
+            continue
+
+        # Exists on disk but not in git HEAD → new file
+        if current and not baseline:
+            changes.append(
+                DetectedChange(
+                    file_path=rel_path,
+                    change_type=ChangeType.NEW_FILE,
+                    confidence=1.0,
+                )
+            )
+            continue
+
+        # Both exist — compare content
+        if _sha256(current) == _sha256(baseline):
+            continue  # unchanged
+
+        # --- Content differs — classify ---
+        baseline_blocks = parse_aimb_blocks(baseline)
+        current_blocks = parse_aimb_blocks(current)
+
+        if not baseline_blocks and not current_blocks:
+            # No AIMB blocks in either version → purely manual change
+            changes.append(
+                DetectedChange(
+                    file_path=rel_path,
+                    change_type=ChangeType.DOC_CHANGED_MANUALLY,
+                    confidence=0.8,
+                )
+            )
+            continue
+
+        # Compare per-block hashes
+        baseline_block_hashes = {
+            b.id: compute_block_hash(b.content) for b in baseline_blocks
+        }
+        current_block_hashes = {
+            b.id: compute_block_hash(b.content) for b in current_blocks
+        }
+
+        changed_block_ids: list[str] = []
+        all_ids = set(baseline_block_hashes) | set(current_block_hashes)
+        for bid in all_ids:
+            old_h = baseline_block_hashes.get(bid)
+            new_h = current_block_hashes.get(bid)
+            if old_h != new_h:
+                changed_block_ids.append(bid)
+
+        if changed_block_ids:
+            # At least one AIMB block content changed
+            # Check whether manual-only (non-AIMB) content also changed
+            baseline_remainder = _strip_aimb_blocks(baseline)
+            current_remainder = _strip_aimb_blocks(current)
+            only_aimb = baseline_remainder == current_remainder
+
+            changes.append(
+                DetectedChange(
+                    file_path=rel_path,
+                    change_type=ChangeType.AIMB_BLOCK_CHANGED,
+                    affected_aimb_blocks=changed_block_ids,
+                    confidence=1.0 if only_aimb else 0.9,
+                )
+            )
+        else:
+            # File content changed but no AIMB block hash changed
+            changes.append(
+                DetectedChange(
+                    file_path=rel_path,
+                    change_type=ChangeType.DOC_CHANGED_MANUALLY,
+                    confidence=0.8,
+                )
+            )
+
+    return changes
+
+
+def classify_changes(all_changes: list[DetectedChange]) -> dict[str, Any]:
+    """Group changes by type and affected documentation.
+
+    Parameters
+    ----------
+    all_changes : list[DetectedChange]
+        Combined results from ``detect_code_changes`` and / or
+        ``detect_doc_changes``.
+
+    Returns
+    -------
+    dict
+        Keys:
+
+        * ``"by_type"``
+            ``{change_type_name: [DetectedChange, ...]}``
+        * ``"by_doc"``
+            ``{doc_or_block_id: [DetectedChange, ...]}``
+        * ``"summary"``
+            Short human-readable string (e.g. ``"3 code_changed, 1 aimb_block_changed"``).
+    """
+    by_type: dict[str, list[DetectedChange]] = {}
+    by_doc: dict[str, list[DetectedChange]] = {}
+
+    for change in all_changes:
+        type_key = change.change_type.name
+        by_type.setdefault(type_key, []).append(change)
+
+        # Group doc changes by the doc file that contains them
+        if change.change_type in (
+            ChangeType.AIMB_BLOCK_CHANGED,
+            ChangeType.DOC_CHANGED_MANUALLY,
+        ):
+            by_doc.setdefault(change.file_path, []).append(change)
+        elif change.affected_aimb_blocks:
+            for bid in change.affected_aimb_blocks:
+                by_doc.setdefault(bid, []).append(change)
+
+    # Build a concise summary line
+    parts: list[str] = []
+    for type_key, items in sorted(by_type.items()):
+        parts.append(f"{len(items)} {type_key.lower()}")
+    summary = ", ".join(parts) if parts else "no changes detected"
+
+    return {
+        "by_type": by_type,
+        "by_doc": by_doc,
+        "summary": summary,
+    }