gobby 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

gobby/storage/clones.py

@@ -0,0 +1,378 @@
+"""Local clone storage manager.
+
+Manages local git clones for parallel development, distinct from worktrees.
+Clones are full repository copies while worktrees share a single .git directory.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Any
+
+from gobby.storage.database import DatabaseProtocol
+from gobby.utils.id import generate_prefixed_id
+
+logger = logging.getLogger(__name__)
+
+
+class CloneStatus(str, Enum):
+    """Clone status values."""
+
+    ACTIVE = "active"
+    SYNCING = "syncing"
+    STALE = "stale"
+    CLEANUP = "cleanup"
+
+
+@dataclass
+class Clone:
+    """Clone data model."""
+
+    id: str
+    project_id: str
+    branch_name: str
+    clone_path: str
+    base_branch: str
+    task_id: str | None
+    agent_session_id: str | None
+    status: str
+    remote_url: str | None
+    last_sync_at: str | None
+    cleanup_after: str | None
+    created_at: str
+    updated_at: str
+
+    @classmethod
+    def from_row(cls, row: Any) -> Clone:
+        """Create Clone from database row."""
+        return cls(
+            id=row["id"],
+            project_id=row["project_id"],
+            branch_name=row["branch_name"],
+            clone_path=row["clone_path"],
+            base_branch=row["base_branch"],
+            task_id=row["task_id"],
+            agent_session_id=row["agent_session_id"],
+            status=row["status"],
+            remote_url=row["remote_url"],
+            last_sync_at=row["last_sync_at"],
+            cleanup_after=row["cleanup_after"],
+            created_at=row["created_at"],
+            updated_at=row["updated_at"],
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "id": self.id,
+            "project_id": self.project_id,
+            "branch_name": self.branch_name,
+            "clone_path": self.clone_path,
+            "base_branch": self.base_branch,
+            "task_id": self.task_id,
+            "agent_session_id": self.agent_session_id,
+            "status": self.status,
+            "remote_url": self.remote_url,
+            "last_sync_at": self.last_sync_at,
+            "cleanup_after": self.cleanup_after,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+        }
+
+
+class LocalCloneManager:
+    """Manager for local clone storage."""
+
+    def __init__(self, db: DatabaseProtocol):
+        """Initialize with database connection."""
+        self.db = db
+
+    def create(
+        self,
+        project_id: str,
+        branch_name: str,
+        clone_path: str,
+        base_branch: str = "main",
+        task_id: str | None = None,
+        agent_session_id: str | None = None,
+        remote_url: str | None = None,
+        cleanup_after: str | None = None,
+    ) -> Clone:
+        """
+        Create a new clone record.
+
+        Args:
+            project_id: Project ID
+            branch_name: Git branch name
+            clone_path: Absolute path to clone directory
+            base_branch: Base branch for the clone
+            task_id: Optional task ID to link
+            agent_session_id: Optional session ID that owns this clone
+            remote_url: Optional remote URL of the repository
+            cleanup_after: Optional ISO timestamp for automatic cleanup
+
+        Returns:
+            Created Clone instance
+        """
+        clone_id = generate_prefixed_id("clone", length=6)
+        now = datetime.now(UTC).isoformat()
+
+        self.db.execute(
+            """
+            INSERT INTO clones (
+                id, project_id, branch_name, clone_path, base_branch,
+                task_id, agent_session_id, status, remote_url,
+                last_sync_at, cleanup_after, created_at, updated_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                clone_id,
+                project_id,
+                branch_name,
+                clone_path,
+                base_branch,
+                task_id,
+                agent_session_id,
+                CloneStatus.ACTIVE.value,
+                remote_url,
+                None,  # last_sync_at
+                cleanup_after,
+                now,
+                now,
+            ),
+        )
+
+        return Clone(
+            id=clone_id,
+            project_id=project_id,
+            branch_name=branch_name,
+            clone_path=clone_path,
+            base_branch=base_branch,
+            task_id=task_id,
+            agent_session_id=agent_session_id,
+            status=CloneStatus.ACTIVE.value,
+            remote_url=remote_url,
+            last_sync_at=None,
+            cleanup_after=cleanup_after,
+            created_at=now,
+            updated_at=now,
+        )
+
+    def get(self, clone_id: str) -> Clone | None:
+        """Get clone by ID."""
+        row = self.db.fetchone("SELECT * FROM clones WHERE id = ?", (clone_id,))
+        return Clone.from_row(row) if row else None
+
+    def get_by_task(self, task_id: str) -> Clone | None:
+        """Get clone linked to a task."""
+        row = self.db.fetchone("SELECT * FROM clones WHERE task_id = ?", (task_id,))
+        return Clone.from_row(row) if row else None
+
+    def get_by_path(self, clone_path: str) -> Clone | None:
+        """Get clone by path."""
+        row = self.db.fetchone("SELECT * FROM clones WHERE clone_path = ?", (clone_path,))
+        return Clone.from_row(row) if row else None
+
+    def get_by_branch(self, project_id: str, branch_name: str) -> Clone | None:
+        """Get clone by project and branch name."""
+        row = self.db.fetchone(
+            "SELECT * FROM clones WHERE project_id = ? AND branch_name = ?",
+            (project_id, branch_name),
+        )
+        return Clone.from_row(row) if row else None
+
+    def list_clones(
+        self,
+        project_id: str | None = None,
+        status: str | None = None,
+        agent_session_id: str | None = None,
+        limit: int = 50,
+    ) -> list[Clone]:
+        """
+        List clones with optional filters.
+
+        Args:
+            project_id: Filter by project
+            status: Filter by status
+            agent_session_id: Filter by owning session
+            limit: Maximum number of results
+
+        Returns:
+            List of Clone instances
+        """
+        conditions = []
+        params: list[Any] = []
+
+        if project_id:
+            conditions.append("project_id = ?")
+            params.append(project_id)
+        if status:
+            conditions.append("status = ?")
+            params.append(status)
+        if agent_session_id:
+            conditions.append("agent_session_id = ?")
+            params.append(agent_session_id)
+
+        where_clause = " AND ".join(conditions) if conditions else "1=1"
+        params.append(limit)
+
+        # nosec B608: where_clause built from hardcoded condition strings, values parameterized
+        rows = self.db.fetchall(
+            f"""
+            SELECT * FROM clones
+            WHERE {where_clause}
+            ORDER BY created_at DESC
+            LIMIT ?
+            """,  # nosec B608
+            tuple(params),
+        )
+        return [Clone.from_row(row) for row in rows]
+
+    # Allowlist of valid clone column names to prevent SQL injection
+    _VALID_UPDATE_FIELDS = frozenset(
+        {
+            "branch_name",
+            "base_branch",
+            "clone_path",
+            "status",
+            "agent_session_id",
+            "task_id",
+            "remote_url",
+            "last_sync_at",
+            "cleanup_after",
+            "updated_at",
+        }
+    )
+
+    def update(self, clone_id: str, **fields: Any) -> Clone | None:
+        """
+        Update clone fields.
+
+        Args:
+            clone_id: Clone ID to update
+            **fields: Fields to update (must be valid column names)
+
+        Returns:
+            Updated Clone or None if not found
+
+        Raises:
+            ValueError: If any field name is not in the allowlist
+        """
+        if not fields:
+            return self.get(clone_id)
+
+        # Validate field names against allowlist to prevent SQL injection
+        invalid_fields = set(fields.keys()) - self._VALID_UPDATE_FIELDS
+        if invalid_fields:
+            raise ValueError(f"Invalid field names: {invalid_fields}")
+
+        # Add updated_at timestamp
+        fields["updated_at"] = datetime.now(UTC).isoformat()
+
+        # nosec B608: Fields validated against _VALID_UPDATE_FIELDS allowlist above
+        set_clause = ", ".join(f"{key} = ?" for key in fields.keys())
+        values = list(fields.values()) + [clone_id]
+
+        self.db.execute(
+            f"UPDATE clones SET {set_clause} WHERE id = ?",  # nosec B608
+            tuple(values),
+        )
+
+        return self.get(clone_id)
+
+    def delete(self, clone_id: str) -> bool:
+        """
+        Delete clone record.
+
+        Args:
+            clone_id: Clone ID to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        cursor = self.db.execute("DELETE FROM clones WHERE id = ?", (clone_id,))
+        return cursor.rowcount > 0
+
+    # Status transition methods
+
+    def mark_syncing(self, clone_id: str) -> Clone | None:
+        """
+        Mark clone as syncing.
+
+        Args:
+            clone_id: Clone ID
+
+        Returns:
+            Updated Clone or None if not found
+        """
+        return self.update(clone_id, status=CloneStatus.SYNCING.value)
+
+    def mark_stale(self, clone_id: str) -> Clone | None:
+        """
+        Mark clone as stale (inactive).
+
+        Args:
+            clone_id: Clone ID
+
+        Returns:
+            Updated Clone or None if not found
+        """
+        return self.update(clone_id, status=CloneStatus.STALE.value)
+
+    def mark_cleanup(self, clone_id: str) -> Clone | None:
+        """
+        Mark clone for cleanup.
+
+        Args:
+            clone_id: Clone ID
+
+        Returns:
+            Updated Clone or None if not found
+        """
+        return self.update(clone_id, status=CloneStatus.CLEANUP.value)
+
+    def record_sync(self, clone_id: str) -> Clone | None:
+        """
+        Record a sync operation on a clone.
+
+        Args:
+            clone_id: Clone ID
+
+        Returns:
+            Updated Clone or None if not found
+        """
+        now = datetime.now(UTC).isoformat()
+        return self.update(
+            clone_id,
+            status=CloneStatus.ACTIVE.value,
+            last_sync_at=now,
+        )
+
+    def claim(self, clone_id: str, session_id: str) -> Clone | None:
+        """
+        Claim a clone for an agent session.
+
+        Args:
+            clone_id: Clone ID
+            session_id: Session ID claiming ownership
+
+        Returns:
+            Updated Clone or None if not found
+        """
+        return self.update(clone_id, agent_session_id=session_id)
+
+    def release(self, clone_id: str) -> Clone | None:
+        """
+        Release a clone from its current owner.
+
+        Args:
+            clone_id: Clone ID
+
+        Returns:
+            Updated Clone or None if not found
+        """
+        return self.update(clone_id, agent_session_id=None)

gobby/storage/database.py

@@ -21,7 +21,7 @@ from typing import TYPE_CHECKING, Any, Protocol, cast, runtime_checkable
 
 def _adapt_datetime(val: datetime) -> str:
     """Adapt datetime to ISO format string for SQLite storage."""
-    return val.isoformat(" ")
+    return val.isoformat()
 
 
 def _adapt_date(val: date) -> str:

gobby/storage/memories.py

@@ -138,10 +138,18 @@ class LocalMemoryManager:
         tags: list[str] | None = None,
         media: str | None = None,
     ) -> Memory:
+        # Validate that content is not empty
+        if not content or not content.strip():
+            logger.warning("Skipping memory creation: empty content provided")
+            raise ValueError("Memory content cannot be empty")
+
         now = datetime.now(UTC).isoformat()
-        # Ensure consistent ID for same content/project to avoid dupes?
-        # Actually random/content-based might be better. Let's use content.
-        memory_id = generate_prefixed_id("mm", content + str(project_id))
+        # Normalize content for consistent ID generation (avoid duplicates from
+        # whitespace differences or project_id inconsistency)
+        normalized_content = content.strip()
+        project_str = project_id if project_id else ""
+        # Use delimiter to prevent collisions (e.g., "abc" + "def" vs "abcd" + "ef")
+        memory_id = generate_prefixed_id("mm", f"{normalized_content}||{project_str}")
 
         # Check if memory already exists to avoid duplicate insert errors
         existing_row = self.db.fetchone("SELECT * FROM memories WHERE id = ?", (memory_id,))
@@ -190,18 +198,40 @@ class LocalMemoryManager:
 
     def content_exists(self, content: str, project_id: str | None = None) -> bool:
         """Check if a memory with identical content already exists."""
-        if project_id:
-            row = self.db.fetchone(
-                "SELECT 1 FROM memories WHERE content = ? AND project_id = ?",
-                (content, project_id),
-            )
-        else:
-            row = self.db.fetchone(
-                "SELECT 1 FROM memories WHERE content = ? AND project_id IS NULL",
-                (content,),
-            )
+        # Normalize content same way as ID generation in create_memory
+        normalized_content = content.strip()
+        project_str = project_id if project_id else ""
+        # Use delimiter to match create_memory ID generation
+        memory_id = generate_prefixed_id("mm", f"{normalized_content}||{project_str}")
+
+        # Check by ID (content-hash based) for consistent dedup
+        row = self.db.fetchone("SELECT 1 FROM memories WHERE id = ?", (memory_id,))
         return row is not None
 
+    def get_memory_by_content(self, content: str, project_id: str | None = None) -> Memory | None:
+        """Get a memory by its exact content, using the content-derived ID.
+
+        This provides a reliable way to fetch an existing memory without
+        relying on search result ordering.
+
+        Args:
+            content: The exact content to look up (will be normalized)
+            project_id: Optional project ID for scoping
+
+        Returns:
+            The Memory object if found, None otherwise
+        """
+        # Normalize content same way as ID generation in create_memory
+        normalized_content = content.strip()
+        project_str = project_id if project_id else ""
+        # Use delimiter to match create_memory ID generation
+        memory_id = generate_prefixed_id("mm", f"{normalized_content}||{project_str}")
+
+        try:
+            return self.get_memory(memory_id)
+        except ValueError:
+            return None
+
     def update_memory(
         self,
         memory_id: str,

gobby/storage/migrations.py

@@ -358,7 +358,7 @@ CREATE TABLE tasks (
     agent_name TEXT,
     reference_doc TEXT,
     is_expanded INTEGER DEFAULT 0,
-    is_tdd_applied INTEGER DEFAULT 0,
+    expansion_status TEXT DEFAULT 'none',
     requires_user_review INTEGER DEFAULT 0,
     accepted_by_user INTEGER DEFAULT 0,
     created_at TEXT NOT NULL,
@@ -606,7 +606,11 @@ def _migrate_add_reference_doc(db: LocalDatabase) -> None:
 
 
 def _migrate_add_boolean_columns(db: LocalDatabase) -> None:
-    """Add is_enriched, is_expanded, is_tdd_applied columns to tasks table."""
+    """Add is_enriched and is_expanded columns to tasks table.
+
+    Note: is_tdd_applied was previously added here but is now deprecated and
+    removed in migration 74. This migration only adds is_enriched and is_expanded.
+    """
     row = db.fetchone("SELECT sql FROM sqlite_master WHERE type='table' AND name='tasks'")
     if not row:
         return
@@ -622,10 +626,6 @@ def _migrate_add_boolean_columns(db: LocalDatabase) -> None:
         db.execute("ALTER TABLE tasks ADD COLUMN is_expanded INTEGER DEFAULT 0")
         logger.info("Added is_expanded column to tasks table")
 
-    if "is_tdd_applied" not in sql_lower:
-        db.execute("ALTER TABLE tasks ADD COLUMN is_tdd_applied INTEGER DEFAULT 0")
-        logger.info("Added is_tdd_applied column to tasks table")
-
 
 def _migrate_add_review_columns(db: LocalDatabase) -> None:
     """Add requires_user_review and accepted_by_user columns for review status support."""
@@ -718,6 +718,168 @@ def _migrate_add_media_column(db: LocalDatabase) -> None:
         logger.debug("media column already exists, skipping")
 
 
+def _migrate_add_expansion_status(db: LocalDatabase) -> None:
+    """Add expansion_status column to tasks table for skill-based expansion."""
+    row = db.fetchone("SELECT sql FROM sqlite_master WHERE type='table' AND name='tasks'")
+    if row and "expansion_status" not in row["sql"].lower():
+        db.execute("ALTER TABLE tasks ADD COLUMN expansion_status TEXT DEFAULT 'none'")
+        logger.info("Added expansion_status column to tasks table")
+    else:
+        logger.debug("expansion_status column already exists, skipping")
+
+
+def _migrate_add_skills_table(db: LocalDatabase) -> None:
+    """Add skills table for Agent Skills spec compliant skill storage.
+
+    Skills provide structured instructions for AI agents following the
+    Agent Skills specification (agentskills.io) with Gobby-specific extensions.
+    """
+    # Check if table already exists
+    row = db.fetchone("SELECT name FROM sqlite_master WHERE type='table' AND name='skills'")
+    if row:
+        logger.debug("skills table already exists, skipping")
+        return
+
+    # Create the skills table
+    db.execute("""
+        CREATE TABLE skills (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            description TEXT NOT NULL,
+            content TEXT NOT NULL,
+            version TEXT,
+            license TEXT,
+            compatibility TEXT,
+            allowed_tools TEXT,
+            metadata TEXT,
+            source_path TEXT,
+            source_type TEXT,
+            source_ref TEXT,
+            enabled INTEGER DEFAULT 1,
+            project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+    """)
+
+    # Create indexes
+    db.execute("CREATE INDEX idx_skills_name ON skills(name)")
+    db.execute("CREATE INDEX idx_skills_project_id ON skills(project_id)")
+    db.execute("CREATE INDEX idx_skills_enabled ON skills(enabled)")
+    # Unique constraint: name must be unique within a project scope
+    db.execute("CREATE UNIQUE INDEX idx_skills_name_project ON skills(name, project_id)")
+    # Partial unique index for global skills (project_id IS NULL)
+    # This enforces uniqueness for global skill names since NULL != NULL in SQL
+    db.execute(
+        "CREATE UNIQUE INDEX idx_skills_name_global ON skills(name) WHERE project_id IS NULL"
+    )
+
+    logger.info("Created skills table with indexes")
+
+
+def _migrate_add_skills_global_unique_index(db: LocalDatabase) -> None:
+    """Add partial unique index for global skills (project_id IS NULL).
+
+    This enforces uniqueness for global skill names since NULL != NULL in SQL.
+    The existing idx_skills_name_project only enforces uniqueness within a project scope.
+    """
+    # Check if index already exists (fresh database from v70+)
+    row = db.fetchone(
+        "SELECT name FROM sqlite_master WHERE type='index' AND name='idx_skills_name_global'"
+    )
+    if row:
+        logger.debug("idx_skills_name_global index already exists, skipping")
+        return
+
+    # Check if skills table exists (might not if on old version that never created it)
+    row = db.fetchone("SELECT name FROM sqlite_master WHERE type='table' AND name='skills'")
+    if not row:
+        logger.debug("skills table does not exist, skipping")
+        return
+
+    db.execute(
+        "CREATE UNIQUE INDEX idx_skills_name_global ON skills(name) WHERE project_id IS NULL"
+    )
+    logger.debug("Added idx_skills_name_global partial unique index to skills table")
+
+
+def _migrate_add_clones_table(db: LocalDatabase) -> None:
+    """Add clones table for local git clone management.
+
+    Clones are full repository copies, distinct from worktrees which share
+    a single .git directory. This enables parallel development across machines
+    or isolated environments.
+    """
+    # Check if table already exists
+    row = db.fetchone("SELECT name FROM sqlite_master WHERE type='table' AND name='clones'")
+    if row:
+        logger.debug("clones table already exists, skipping")
+        return
+
+    # Create the clones table
+    db.execute("""
+        CREATE TABLE clones (
+            id TEXT PRIMARY KEY,
+            project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+            branch_name TEXT NOT NULL,
+            clone_path TEXT NOT NULL,
+            base_branch TEXT DEFAULT 'main',
+            task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+            agent_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+            status TEXT DEFAULT 'active',
+            remote_url TEXT,
+            last_sync_at TEXT,
+            cleanup_after TEXT,
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+    """)
+
+    # Create indexes
+    db.execute("CREATE INDEX idx_clones_project ON clones(project_id)")
+    db.execute("CREATE INDEX idx_clones_status ON clones(status)")
+    db.execute("CREATE INDEX idx_clones_task ON clones(task_id)")
+    db.execute("CREATE INDEX idx_clones_session ON clones(agent_session_id)")
+    db.execute("CREATE UNIQUE INDEX idx_clones_path ON clones(clone_path)")
+
+    logger.debug("Created clones table with indexes")
+
+
+def _migrate_add_model_column(db: LocalDatabase) -> None:
+    """Add model column to sessions table for cost tracking by model.
+
+    This enables the TokenTracker to aggregate usage by model and apply
+    model-specific pricing for budget tracking.
+    """
+    row = db.fetchone("SELECT sql FROM sqlite_master WHERE type='table' AND name='sessions'")
+    if row and "model" not in row["sql"].lower():
+        db.execute("ALTER TABLE sessions ADD COLUMN model TEXT")
+        logger.info("Added model column to sessions table")
+    else:
+        logger.debug("model column already exists, skipping")
+
+
+def _migrate_drop_is_tdd_applied(db: LocalDatabase) -> None:
+    """Drop deprecated is_tdd_applied column from tasks table.
+
+    The is_tdd_applied flag is no longer used after removing the TDD sandwich pattern.
+    TDD instructions are now embedded directly in task descriptions for code/config categories.
+    SQLite 3.35.0+ supports ALTER TABLE DROP COLUMN.
+    """
+    row = db.fetchone("SELECT sql FROM sqlite_master WHERE type='table' AND name='tasks'")
+    if not row:
+        return
+
+    if "is_tdd_applied" in row["sql"].lower():
+        try:
+            db.execute("ALTER TABLE tasks DROP COLUMN is_tdd_applied")
+            logger.info("Dropped is_tdd_applied column from tasks table")
+        except Exception as e:
+            # SQLite < 3.35.0 doesn't support DROP COLUMN
+            # Column will remain but be unused - not a problem
+            logger.warning(f"Could not drop is_tdd_applied column (SQLite < 3.35?): {e}")
+
+
 MIGRATIONS: list[tuple[int, str, MigrationAction]] = [
     # TDD Expansion Restructure: Rename test_strategy to category
     (61, "Rename test_strategy to category", _migrate_test_strategy_to_category),
@@ -735,6 +897,18 @@ MIGRATIONS: list[tuple[int, str, MigrationAction]] = [
     (67, "Add inter_session_messages table", _migrate_add_inter_session_messages),
     # Memory V3 Phase 2: Add media column for multimodal support
     (68, "Add media column to memories", _migrate_add_media_column),
+    # Skill-based expansion: Add expansion_status column to tasks
+    (69, "Add expansion_status column to tasks", _migrate_add_expansion_status),
+    # Skills storage: Add skills table for Agent Skills spec
+    (70, "Add skills table", _migrate_add_skills_table),
+    # Skills: Add partial unique index for global skills
+    (71, "Add global skills unique index", _migrate_add_skills_global_unique_index),
+    # Local clones: Add table for git clone management
+    (72, "Add clones table", _migrate_add_clones_table),
+    # Token tracking: Add model column to sessions for cost tracking by model
+    (73, "Add model column to sessions", _migrate_add_model_column),
+    # TDD cleanup: Drop unused is_tdd_applied column from tasks
+    (74, "Drop is_tdd_applied column from tasks", _migrate_drop_is_tdd_applied),
 ]