gobby 0.2.5__py3-none-any.whl

gobby/storage/artifact_classifier.py

@@ -0,0 +1,341 @@
+"""Artifact type classifier.
+
+Automatically classifies content into artifact types:
+- code: Programming language code blocks
+- file_path: File or directory paths
+- error: Error messages and stack traces
+- command_output: Terminal/shell command output
+- structured_data: JSON, YAML, TOML, XML
+- text: Plain text (default)
+
+Also extracts relevant metadata for each type (language, extension, format, etc.)
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+__all__ = ["ArtifactType", "ClassificationResult", "classify_artifact"]
+
+
+class ArtifactType(str, Enum):
+    """Artifact type enumeration."""
+
+    CODE = "code"
+    FILE_PATH = "file_path"
+    ERROR = "error"
+    COMMAND_OUTPUT = "command_output"
+    STRUCTURED_DATA = "structured_data"
+    TEXT = "text"
+
+
+@dataclass
+class ClassificationResult:
+    """Result of artifact classification."""
+
+    artifact_type: ArtifactType
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "artifact_type": self.artifact_type.value,
+            "metadata": self.metadata,
+        }
+
+
+# Language detection patterns (more specific patterns first)
+_LANGUAGE_PATTERNS: list[tuple[str, re.Pattern[str]]] = [
+    # Python
+    (
+        "python",
+        re.compile(
+            r"^\s*(def\s+\w+|class\s+\w+|import\s+\w+|from\s+\w+\s+import|async\s+def\s+\w+|@\w+)",
+            re.MULTILINE,
+        ),
+    ),
+    # TypeScript (must be before JavaScript - has interface/type)
+    (
+        "typescript",
+        re.compile(
+            r"^\s*(interface\s+\w+|type\s+\w+\s*=|:\s*(string|number|boolean|any)\b)", re.MULTILINE
+        ),
+    ),
+    # JavaScript
+    (
+        "javascript",
+        re.compile(
+            r"^\s*(function\s+\w+|const\s+\w+\s*=|let\s+\w+\s*=|var\s+\w+\s*=|=>\s*\{)",
+            re.MULTILINE,
+        ),
+    ),
+    # Rust
+    (
+        "rust",
+        re.compile(
+            r"^\s*(fn\s+\w+|impl\s+|struct\s+\w+|enum\s+\w+|use\s+\w+|pub\s+fn)", re.MULTILINE
+        ),
+    ),
+    # Go
+    ("go", re.compile(r"^\s*(func\s+\w+|func\s+\(\w+|package\s+\w+|import\s+\()", re.MULTILINE)),
+    # SQL
+    (
+        "sql",
+        re.compile(
+            r"^\s*(SELECT\s+|INSERT\s+INTO|UPDATE\s+\w+\s+SET|DELETE\s+FROM|CREATE\s+TABLE|DROP\s+TABLE)",
+            re.IGNORECASE | re.MULTILINE,
+        ),
+    ),
+    # Shell/Bash
+    (
+        "bash",
+        re.compile(
+            r"(^#!/bin/(ba)?sh|^\s*for\s+\w+\s+in\s+|^\s*if\s+\[\[?\s+|^\s*while\s+|echo\s+[\"'])",
+            re.MULTILINE,
+        ),
+    ),
+]
+
+# Markdown code fence pattern
+_CODE_FENCE_PATTERN = re.compile(r"^```(\w*).*?\n(.*?)```", re.DOTALL | re.MULTILINE)
+
+# File path patterns
+_UNIX_PATH_PATTERN = re.compile(r"^(/[\w./\-_]+|\.{1,2}/[\w./\-_]+)$")
+_WINDOWS_PATH_PATTERN = re.compile(r"^[A-Za-z]:\\[\w\\/.\-_]+$")
+_RELATIVE_PATH_PATTERN = re.compile(r"^[\w\-_]+/[\w./\-_]+\.\w+$")
+
+# Error patterns
+_ERROR_PATTERNS = [
+    re.compile(r"^Traceback \(most recent call last\):", re.MULTILINE),
+    re.compile(r"^\w+Error:\s+", re.MULTILINE),
+    re.compile(r"^TypeError:\s+", re.MULTILINE),
+    re.compile(r"^Exception\s+", re.MULTILINE),
+    re.compile(r"^Error:\s+", re.MULTILINE),
+    re.compile(r"thread\s+'.*'\s+panicked\s+at", re.MULTILINE),
+    re.compile(r"^\s+at\s+[\w.]+\([\w.]+:\d+\)$", re.MULTILINE),  # JS stack trace line
+]
+
+# Command output patterns
+_COMMAND_OUTPUT_PATTERNS = [
+    re.compile(r"^On branch\s+\w+", re.MULTILINE),  # git status
+    re.compile(r"^\$ \w+", re.MULTILINE),  # shell prompt
+    re.compile(r"^npm\s+(WARN|ERR!?|notice)", re.MULTILINE),  # npm
+    re.compile(r"^={3,}\s+test session starts\s+={3,}$", re.MULTILINE),  # pytest
+    re.compile(r"^total\s+\d+\s*$", re.MULTILINE),  # ls -l
+    re.compile(r"^(d|-)rwx", re.MULTILINE),  # ls -l permissions
+    re.compile(r"^added\s+\d+\s+packages?", re.MULTILINE),  # npm install
+    re.compile(r"^collected\s+\d+\s+items?", re.MULTILINE),  # pytest
+    re.compile(r"^\d+\s+passed", re.MULTILINE),  # pytest results
+]
+
+
+def _detect_language(content: str) -> str | None:
+    """Detect programming language from content."""
+    for lang, pattern in _LANGUAGE_PATTERNS:
+        if pattern.search(content):
+            return lang
+    return None
+
+
+def _is_file_path(content: str) -> tuple[bool, dict[str, Any]]:
+    """Check if content is a file path and extract metadata."""
+    content = content.strip()
+
+    # Don't classify multi-line content as a file path
+    if "\n" in content:
+        return False, {}
+
+    metadata: dict[str, Any] = {}
+
+    # Check patterns
+    if _UNIX_PATH_PATTERN.match(content):
+        pass
+    elif _WINDOWS_PATH_PATTERN.match(content):
+        pass
+    elif _RELATIVE_PATH_PATTERN.match(content):
+        pass
+    else:
+        return False, {}
+
+    # Extract filename and extension
+    parts = content.replace("\\", "/").split("/")
+    filename = parts[-1]
+    metadata["filename"] = filename
+
+    if "." in filename:
+        ext = filename.rsplit(".", 1)[-1]
+        metadata["extension"] = ext
+    else:
+        metadata["extension"] = None
+
+    return True, metadata
+
+
+def _is_error(content: str) -> bool:
+    """Check if content is an error message or stack trace."""
+    for pattern in _ERROR_PATTERNS:
+        if pattern.search(content):
+            return True
+    return False
+
+
+def _is_command_output(content: str) -> bool:
+    """Check if content is command output."""
+    for pattern in _COMMAND_OUTPUT_PATTERNS:
+        if pattern.search(content):
+            return True
+    return False
+
+
+def _is_json(content: str) -> bool:
+    """Check if content is valid JSON."""
+    content = content.strip()
+    if not (content.startswith("{") or content.startswith("[")):
+        return False
+    try:
+        json.loads(content)
+        return True
+    except (json.JSONDecodeError, ValueError):
+        return False
+
+
+def _is_yaml(content: str) -> bool:
+    """Check if content looks like YAML (simple heuristic)."""
+    content = content.strip()
+    lines = content.split("\n")
+
+    # YAML typically has key: value patterns
+    # Must have actual values after the colon (not just colons in prose)
+    yaml_kv_pattern = re.compile(r"^\s*[\w\-_]+:\s*\S")
+    yaml_list_with_kv_pattern = re.compile(r"^\s*-\s+[\w\-_]+:\s*")
+
+    yaml_kv_lines = 0
+    total_non_empty = 0
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        total_non_empty += 1
+        # Count lines with key: value pattern (not just list items)
+        if yaml_kv_pattern.match(line) or yaml_list_with_kv_pattern.match(line):
+            yaml_kv_lines += 1
+
+    # Need at least 2 key-value lines and they should be significant portion
+    return yaml_kv_lines >= 2 and (yaml_kv_lines / max(total_non_empty, 1)) > 0.3
+
+
+def _is_toml(content: str) -> bool:
+    """Check if content looks like TOML."""
+    content = content.strip()
+
+    # TOML has [section] headers and key = value
+    section_pattern = re.compile(r"^\s*\[[\w.\-]+\]\s*$", re.MULTILINE)
+    kv_pattern = re.compile(r"^\s*[\w\-]+\s*=\s*", re.MULTILINE)
+
+    has_section = section_pattern.search(content) is not None
+    has_kv = kv_pattern.search(content) is not None
+
+    return has_section and has_kv
+
+
+def _is_xml(content: str) -> bool:
+    """Check if content looks like XML."""
+    content = content.strip()
+
+    # XML starts with <?xml or <tag>
+    if content.startswith("<?xml"):
+        return True
+
+    # Check for matching opening/closing tags
+    tag_pattern = re.compile(r"^<(\w+)[^>]*>.*</\1>", re.DOTALL)
+    return tag_pattern.match(content) is not None
+
+
+def _is_code_block(content: str) -> tuple[bool, dict[str, Any]]:
+    """Check if content is a markdown code block and extract language."""
+    match = _CODE_FENCE_PATTERN.match(content.strip())
+    if match:
+        lang = match.group(1).lower() if match.group(1) else None
+        return True, {"language": lang} if lang else {}
+    return False, {}
+
+
+def classify_artifact(content: str) -> ClassificationResult:
+    """
+    Classify content into an artifact type with metadata.
+
+    Args:
+        content: The content to classify
+
+    Returns:
+        ClassificationResult with artifact_type and extracted metadata
+    """
+    if not content or not content.strip():
+        return ClassificationResult(artifact_type=ArtifactType.TEXT, metadata={})
+
+    # Check for markdown code fence first
+    is_code_fence, fence_metadata = _is_code_block(content)
+    if is_code_fence:
+        metadata = fence_metadata.copy()
+        # If no language in fence, try to detect from content
+        if "language" not in metadata or not metadata["language"]:
+            inner_content = _CODE_FENCE_PATTERN.match(content.strip())
+            if inner_content:
+                detected_lang = _detect_language(inner_content.group(2))
+                if detected_lang:
+                    metadata["language"] = detected_lang
+        return ClassificationResult(artifact_type=ArtifactType.CODE, metadata=metadata)
+
+    # Check for file path (single line only)
+    is_path, path_metadata = _is_file_path(content)
+    if is_path:
+        return ClassificationResult(artifact_type=ArtifactType.FILE_PATH, metadata=path_metadata)
+
+    # Check for error messages/stack traces
+    if _is_error(content):
+        metadata = {}
+        # Try to extract error type
+        error_match = re.search(r"^(\w+Error):", content, re.MULTILINE)
+        if error_match:
+            metadata["error"] = error_match.group(1)
+        return ClassificationResult(artifact_type=ArtifactType.ERROR, metadata=metadata)
+
+    # Check for code patterns BEFORE structured data
+    # (TypeScript interfaces look like YAML otherwise)
+    detected_lang = _detect_language(content)
+    if detected_lang:
+        return ClassificationResult(
+            artifact_type=ArtifactType.CODE, metadata={"language": detected_lang}
+        )
+
+    # Check for structured data formats
+    if _is_json(content):
+        return ClassificationResult(
+            artifact_type=ArtifactType.STRUCTURED_DATA, metadata={"format": "json"}
+        )
+
+    if _is_xml(content):
+        return ClassificationResult(
+            artifact_type=ArtifactType.STRUCTURED_DATA, metadata={"format": "xml"}
+        )
+
+    if _is_toml(content):
+        return ClassificationResult(
+            artifact_type=ArtifactType.STRUCTURED_DATA, metadata={"format": "toml"}
+        )
+
+    if _is_yaml(content):
+        return ClassificationResult(
+            artifact_type=ArtifactType.STRUCTURED_DATA, metadata={"format": "yaml"}
+        )
+
+    # Check for command output
+    if _is_command_output(content):
+        return ClassificationResult(artifact_type=ArtifactType.COMMAND_OUTPUT, metadata={})
+
+    # Default to text
+    return ClassificationResult(artifact_type=ArtifactType.TEXT, metadata={})

gobby/storage/artifacts.py

@@ -0,0 +1,285 @@
+"""
+Session artifacts storage module.
+
+Stores code snippets, diffs, errors, and other artifacts from sessions
+with optional FTS5 full-text search support.
+"""
+
+import json
+import logging
+import sqlite3
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import Any
+
+from gobby.storage.database import DatabaseProtocol
+from gobby.utils.id import generate_prefixed_id
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Artifact:
+    """A session artifact representing code, diff, error, or other content."""
+
+    id: str
+    session_id: str
+    artifact_type: str
+    content: str
+    created_at: str
+    metadata: dict[str, Any] | None = None
+    source_file: str | None = None
+    line_start: int | None = None
+    line_end: int | None = None
+
+    @classmethod
+    def from_row(cls, row: sqlite3.Row) -> "Artifact":
+        """Create an Artifact from a database row."""
+        metadata_json = row["metadata_json"]
+        metadata = json.loads(metadata_json) if metadata_json else None
+
+        return cls(
+            id=row["id"],
+            session_id=row["session_id"],
+            artifact_type=row["artifact_type"],
+            content=row["content"],
+            created_at=row["created_at"],
+            metadata=metadata,
+            source_file=row["source_file"],
+            line_start=row["line_start"],
+            line_end=row["line_end"],
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert artifact to dictionary for serialization."""
+        return {
+            "id": self.id,
+            "session_id": self.session_id,
+            "artifact_type": self.artifact_type,
+            "content": self.content,
+            "created_at": self.created_at,
+            "metadata": self.metadata,
+            "source_file": self.source_file,
+            "line_start": self.line_start,
+            "line_end": self.line_end,
+        }
+
+
+class LocalArtifactManager:
+    """Manages session artifacts in local SQLite database."""
+
+    def __init__(self, db: DatabaseProtocol):
+        self.db = db
+        self._change_listeners: list[Callable[[], Any]] = []
+
+    def add_change_listener(self, listener: Callable[[], Any]) -> None:
+        """Add a change listener that will be called on create/delete."""
+        self._change_listeners.append(listener)
+
+    def _notify_listeners(self) -> None:
+        """Notify all change listeners."""
+        for listener in self._change_listeners:
+            try:
+                listener()
+            except Exception as e:
+                logger.error(f"Error in artifact change listener: {e}")
+
+    def create_artifact(
+        self,
+        session_id: str,
+        artifact_type: str,
+        content: str,
+        metadata: dict[str, Any] | None = None,
+        source_file: str | None = None,
+        line_start: int | None = None,
+        line_end: int | None = None,
+    ) -> Artifact:
+        """Create a new artifact.
+
+        Args:
+            session_id: ID of the session this artifact belongs to
+            artifact_type: Type of artifact (code, diff, error, etc.)
+            content: The artifact content
+            metadata: Optional metadata dict
+            source_file: Optional source file path
+            line_start: Optional starting line number
+            line_end: Optional ending line number
+
+        Returns:
+            The created Artifact
+        """
+        now = datetime.now(UTC).isoformat()
+        artifact_id = generate_prefixed_id("art", content[:50] + session_id)
+
+        metadata_json = json.dumps(metadata) if metadata else None
+
+        with self.db.transaction() as conn:
+            conn.execute(
+                """
+                INSERT INTO session_artifacts (
+                    id, session_id, artifact_type, content, metadata_json,
+                    source_file, line_start, line_end, created_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    artifact_id,
+                    session_id,
+                    artifact_type,
+                    content,
+                    metadata_json,
+                    source_file,
+                    line_start,
+                    line_end,
+                    now,
+                ),
+            )
+            # Also insert into FTS5 table for full-text search
+            conn.execute(
+                "INSERT INTO session_artifacts_fts (id, content) VALUES (?, ?)",
+                (artifact_id, content),
+            )
+
+        self._notify_listeners()
+        return self.get_artifact(artifact_id)  # type: ignore[return-value]
+
+    def get_artifact(self, artifact_id: str) -> Artifact | None:
+        """Get an artifact by ID.
+
+        Args:
+            artifact_id: The artifact ID
+
+        Returns:
+            The Artifact if found, None otherwise
+        """
+        row = self.db.fetchone("SELECT * FROM session_artifacts WHERE id = ?", (artifact_id,))
+        if not row:
+            return None
+        return Artifact.from_row(row)
+
+    def list_artifacts(
+        self,
+        session_id: str | None = None,
+        artifact_type: str | None = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> list[Artifact]:
+        """List artifacts with optional filters.
+
+        Args:
+            session_id: Filter by session ID
+            artifact_type: Filter by artifact type
+            limit: Maximum number of results
+            offset: Offset for pagination
+
+        Returns:
+            List of matching Artifacts
+        """
+        query = "SELECT * FROM session_artifacts WHERE 1=1"
+        params: list[Any] = []
+
+        if session_id:
+            query += " AND session_id = ?"
+            params.append(session_id)
+
+        if artifact_type:
+            query += " AND artifact_type = ?"
+            params.append(artifact_type)
+
+        query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+
+        rows = self.db.fetchall(query, tuple(params))
+        return [Artifact.from_row(row) for row in rows]
+
+    def delete_artifact(self, artifact_id: str) -> bool:
+        """Delete an artifact by ID.
+
+        Args:
+            artifact_id: The artifact ID to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        with self.db.transaction() as conn:
+            cursor = conn.execute("DELETE FROM session_artifacts WHERE id = ?", (artifact_id,))
+            if cursor.rowcount == 0:
+                return False
+            # Also delete from FTS5 table
+            conn.execute("DELETE FROM session_artifacts_fts WHERE id = ?", (artifact_id,))
+
+        self._notify_listeners()
+        return True
+
+    def search_artifacts(
+        self,
+        query_text: str,
+        session_id: str | None = None,
+        artifact_type: str | None = None,
+        limit: int = 50,
+    ) -> list[Artifact]:
+        """Search artifacts by content using FTS5 full-text search.
+
+        Uses FTS5 MATCH query on session_artifacts_fts with bm25 ranking.
+        Can optionally filter by session_id and/or artifact_type.
+
+        Args:
+            query_text: The search query text
+            session_id: Optional session ID filter
+            artifact_type: Optional artifact type filter
+            limit: Maximum number of results (default: 50)
+
+        Returns:
+            List of matching Artifacts ordered by relevance (bm25 ranking)
+        """
+        # Empty query returns empty results
+        if not query_text or not query_text.strip():
+            return []
+
+        # Escape FTS5 special characters and build query
+        # Split into words and add prefix matching for each term
+        words = query_text.strip().split()
+        if not words:
+            return []
+
+        # Build FTS5 query: each word becomes a prefix search term
+        # e.g., "calculate total" -> "calculate* total*"
+        fts_terms = []
+        for word in words:
+            # Remove FTS5 special chars that would break syntax: * ^ " ( ) AND OR NOT
+            # Keep only alphanumeric and safe punctuation
+            sanitized = ""
+            for char in word:
+                if char.isalnum() or char in "-_":
+                    sanitized += char
+            if sanitized:
+                fts_terms.append(f"{sanitized}*")
+
+        if not fts_terms:
+            return []
+
+        fts_query = " ".join(fts_terms)
+
+        # Use FTS5 MATCH query with JOIN to main table
+        # Order by bm25() for relevance ranking (lower bm25 = more relevant)
+        sql = """
+            SELECT sa.*
+            FROM session_artifacts sa
+            INNER JOIN session_artifacts_fts fts ON sa.id = fts.id
+            WHERE fts.content MATCH ?
+        """
+        params: list[Any] = [fts_query]
+
+        if session_id:
+            sql += " AND sa.session_id = ?"
+            params.append(session_id)
+
+        if artifact_type:
+            sql += " AND sa.artifact_type = ?"
+            params.append(artifact_type)
+
+        sql += " ORDER BY bm25(session_artifacts_fts) LIMIT ?"
+        params.append(limit)
+
+        rows = self.db.fetchall(sql, tuple(params))
+        return [Artifact.from_row(row) for row in rows]

gobby/storage/compaction.py

@@ -0,0 +1,67 @@
+"""Task compaction logic."""
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from gobby.storage.tasks import LocalTaskManager
+
+
+class TaskCompactor:
+    """Handles compaction of old closed tasks."""
+
+    def __init__(self, task_manager: LocalTaskManager) -> None:
+        self.task_manager = task_manager
+
+    def find_candidates(self, days_closed: int = 30) -> list[dict[str, Any]]:
+        """
+        Find tasks that have been closed for longer than the specified days
+        and haven't been compacted yet.
+        """
+        cutoff = datetime.now(UTC) - timedelta(days=days_closed)
+        cutoff_str = cutoff.isoformat()
+
+        # Query directly since we need custom filtering not exposed by list_tasks
+        sql = """
+            SELECT * FROM tasks
+            WHERE status = 'closed'
+              AND updated_at < ?
+              AND compacted_at IS NULL
+            ORDER BY updated_at ASC
+        """
+        rows = self.task_manager.db.fetchall(sql, (cutoff_str,))
+        return [dict(row) for row in rows]
+
+    def compact_task(self, task_id: str, summary: str) -> None:
+        """
+        Compact a task by replacing its description with a summary.
+        """
+        # Update database directly to set compacted_at
+        now = datetime.now(UTC).isoformat()
+
+        # We preserve the title but replace description with summary
+        # and mark it as compacted.
+        sql = """
+            UPDATE tasks
+            SET description = ?,
+                summary = ?,
+                compacted_at = ?,
+                updated_at = ?
+            WHERE id = ?
+        """
+
+        self.task_manager.db.execute(sql, (summary, summary, now, now, task_id))
+        self.task_manager._notify_listeners()
+
+    def get_stats(self) -> dict[str, Any]:
+        """Get compaction statistics."""
+        sql_total = "SELECT COUNT(*) as c FROM tasks WHERE status = 'closed'"
+        sql_compacted = "SELECT COUNT(*) as c FROM tasks WHERE compacted_at IS NOT NULL"
+
+        total = (self.task_manager.db.fetchone(sql_total) or {"c": 0})["c"]
+        compacted = (self.task_manager.db.fetchone(sql_compacted) or {"c": 0})["c"]
+
+        return {
+            "total_closed": total,
+            "compacted": compacted,
+            "rate": round(compacted / total * 100, 1) if total > 0 else 0,
+        }