doit-toolkit-cli 0.1.10__py3-none-any.whl

doit_cli/models/search_models.py

@@ -0,0 +1,228 @@
+"""Search models for memory search and query functionality.
+
+This module provides data models for the memory search feature, including
+query types, search results, and memory sources.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+import uuid
+
+
+class QueryType(str, Enum):
+    """Type of search query."""
+
+    KEYWORD = "keyword"  # Simple word/phrase search
+    PHRASE = "phrase"  # Exact phrase (quoted)
+    NATURAL = "natural"  # Natural language question
+    REGEX = "regex"  # Regular expression
+
+
+class SourceType(str, Enum):
+    """Type of memory source file."""
+
+    GOVERNANCE = "governance"  # constitution, roadmap, completed_roadmap
+    SPEC = "spec"  # spec.md files
+
+
+class SourceFilter(str, Enum):
+    """Filter for source types to search."""
+
+    ALL = "all"  # Search everything
+    GOVERNANCE = "governance"  # Only governance files
+    SPECS = "specs"  # Only spec files
+
+
+@dataclass
+class SearchQuery:
+    """Represents a user's search request with all parameters.
+
+    Attributes:
+        id: Unique identifier (UUID)
+        query_text: The search term or natural language question
+        query_type: Type of query (KEYWORD, PHRASE, NATURAL, REGEX)
+        timestamp: When the query was executed
+        source_filter: Filter to specific source types (default: ALL)
+        max_results: Maximum results to return (default: 20)
+        case_sensitive: Case-sensitive matching (default: False)
+        use_regex: Interpret query as regex (default: False)
+    """
+
+    query_text: str
+    query_type: QueryType = QueryType.KEYWORD
+    timestamp: datetime = field(default_factory=datetime.now)
+    source_filter: SourceFilter = SourceFilter.ALL
+    max_results: int = 20
+    case_sensitive: bool = False
+    use_regex: bool = False
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+    def __post_init__(self):
+        """Validate query after initialization."""
+        if not self.query_text or not self.query_text.strip():
+            raise ValueError("Query text cannot be empty")
+        if len(self.query_text) > 500:
+            raise ValueError("Query text exceeds maximum length of 500 characters")
+        if not 1 <= self.max_results <= 100:
+            raise ValueError("Max results must be between 1 and 100")
+
+
+@dataclass
+class SearchResult:
+    """A single search match with context and scoring.
+
+    Attributes:
+        id: Unique identifier
+        query_id: Reference to parent query
+        source_id: Reference to source file
+        relevance_score: Score between 0.0 and 1.0
+        line_number: Line where match was found
+        matched_text: The actual matched text
+        context_before: Lines before the match
+        context_after: Lines after the match
+    """
+
+    query_id: str
+    source_id: str
+    relevance_score: float
+    line_number: int
+    matched_text: str
+    context_before: str = ""
+    context_after: str = ""
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+    def __post_init__(self):
+        """Validate result after initialization."""
+        if not 0.0 <= self.relevance_score <= 1.0:
+            raise ValueError("Relevance score must be between 0.0 and 1.0")
+
+
+@dataclass
+class MemorySource:
+    """A searchable file in the project memory.
+
+    Attributes:
+        id: Unique identifier (file path hash)
+        file_path: Absolute path to the file
+        source_type: Classification (GOVERNANCE, SPEC)
+        last_modified: File modification timestamp
+        line_count: Total lines in file
+        token_count: Estimated token count
+    """
+
+    file_path: Path
+    source_type: SourceType
+    last_modified: datetime = field(default_factory=datetime.now)
+    line_count: int = 0
+    token_count: int = 0
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+    @classmethod
+    def from_path(cls, path: Path, source_type: SourceType) -> "MemorySource":
+        """Create a MemorySource from a file path.
+
+        Args:
+            path: Path to the file
+            source_type: Type of source (governance or spec)
+
+        Returns:
+            MemorySource instance
+        """
+        import hashlib
+
+        file_id = hashlib.md5(str(path).encode()).hexdigest()[:16]
+        last_modified = datetime.fromtimestamp(path.stat().st_mtime)
+
+        content = path.read_text(encoding="utf-8")
+        line_count = len(content.splitlines())
+
+        # Estimate tokens (approximately 4 chars per token)
+        token_count = max(1, len(content) // 4)
+
+        return cls(
+            id=file_id,
+            file_path=path,
+            source_type=source_type,
+            last_modified=last_modified,
+            line_count=line_count,
+            token_count=token_count,
+        )
+
+
+@dataclass
+class ContentSnippet:
+    """A portion of text extracted for display.
+
+    Attributes:
+        id: Unique identifier
+        source_id: Reference to source file
+        content: The snippet text
+        start_line: First line number
+        end_line: Last line number
+        highlights: Character positions to highlight [(start, end), ...]
+    """
+
+    source_id: str
+    content: str
+    start_line: int
+    end_line: int
+    highlights: list[tuple[int, int]] = field(default_factory=list)
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+    MAX_CONTENT_LENGTH = 1000
+
+    def __post_init__(self):
+        """Validate and truncate content if needed."""
+        if len(self.content) > self.MAX_CONTENT_LENGTH:
+            # Truncate at word boundary if possible
+            truncated = self.content[: self.MAX_CONTENT_LENGTH]
+            last_space = truncated.rfind(" ")
+            if last_space > self.MAX_CONTENT_LENGTH - 100:
+                truncated = truncated[:last_space]
+            self.content = truncated + "..."
+
+
+@dataclass
+class SearchHistory:
+    """Session-scoped history of queries.
+
+    Attributes:
+        session_id: Unique session identifier
+        session_start: When session began
+        entries: List of past queries
+        max_entries: Maximum entries to keep (default: 10)
+    """
+
+    session_start: datetime = field(default_factory=datetime.now)
+    entries: list[SearchQuery] = field(default_factory=list)
+    max_entries: int = 10
+    session_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+    def add_query(self, query: SearchQuery) -> None:
+        """Add a query to history, enforcing max entries.
+
+        Args:
+            query: The query to add
+        """
+        self.entries.append(query)
+        # FIFO when limit reached
+        while len(self.entries) > self.max_entries:
+            self.entries.pop(0)
+
+    def clear(self) -> None:
+        """Clear all history entries."""
+        self.entries.clear()
+
+    def get_recent(self, count: int = 10) -> list[SearchQuery]:
+        """Get most recent queries.
+
+        Args:
+            count: Number of queries to return
+
+        Returns:
+            List of most recent queries (newest first)
+        """
+        return list(reversed(self.entries[-count:]))

doit_cli/models/status_models.py

@@ -0,0 +1,195 @@
+"""Models for spec status dashboard."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+from .validation_models import ValidationResult
+
+
+class SpecState(str, Enum):
+    """Valid specification statuses parsed from spec.md frontmatter.
+
+    Values:
+        DRAFT: Initial state, not yet validated by git hooks
+        IN_PROGRESS: Active development, validated on commit
+        COMPLETE: Implementation finished, pending approval
+        APPROVED: Fully approved and merged
+        ERROR: Could not parse status from file
+    """
+
+    DRAFT = "draft"
+    IN_PROGRESS = "in_progress"
+    COMPLETE = "complete"
+    APPROVED = "approved"
+    ERROR = "error"
+
+    @classmethod
+    def from_string(cls, value: str) -> "SpecState":
+        """Parse a status string into a SpecState enum.
+
+        Args:
+            value: Status string from spec file (e.g., "Draft", "In Progress")
+
+        Returns:
+            Corresponding SpecState enum value, or ERROR if not recognized.
+        """
+        # Normalize: lowercase and replace spaces with underscores
+        normalized = value.lower().strip().replace(" ", "_")
+
+        # Map common variations
+        mapping = {
+            "draft": cls.DRAFT,
+            "in_progress": cls.IN_PROGRESS,
+            "inprogress": cls.IN_PROGRESS,
+            "in-progress": cls.IN_PROGRESS,
+            "complete": cls.COMPLETE,
+            "completed": cls.COMPLETE,
+            "approved": cls.APPROVED,
+            "done": cls.APPROVED,
+        }
+
+        return mapping.get(normalized, cls.ERROR)
+
+    @property
+    def display_name(self) -> str:
+        """Human-readable display name for the status."""
+        names = {
+            SpecState.DRAFT: "Draft",
+            SpecState.IN_PROGRESS: "In Progress",
+            SpecState.COMPLETE: "Complete",
+            SpecState.APPROVED: "Approved",
+            SpecState.ERROR: "Error",
+        }
+        return names.get(self, "Unknown")
+
+    @property
+    def emoji(self) -> str:
+        """Emoji representation for terminal display."""
+        emojis = {
+            SpecState.DRAFT: "📝",
+            SpecState.IN_PROGRESS: "🔄",
+            SpecState.COMPLETE: "✅",
+            SpecState.APPROVED: "🏆",
+            SpecState.ERROR: "❌",
+        }
+        return emojis.get(self, "❓")
+
+
+@dataclass
+class SpecStatus:
+    """Represents the parsed status of a single specification.
+
+    Attributes:
+        name: Spec name derived from directory name (e.g., "032-status-dashboard")
+        path: Full path to the spec.md file
+        status: Current status (Draft, In Progress, Complete, Approved)
+        last_modified: File modification timestamp
+        validation_result: Result from SpecValidator (if validated)
+        is_blocking: Whether this spec would block commits
+        error: Parse error message if spec couldn't be read
+    """
+
+    name: str
+    path: Path
+    status: SpecState
+    last_modified: datetime
+    validation_result: Optional[ValidationResult] = None
+    is_blocking: bool = False
+    error: Optional[str] = None
+
+    @property
+    def validation_passed(self) -> bool:
+        """Check if validation passed (or wasn't run)."""
+        if self.validation_result is None:
+            return True  # No validation = no failures
+        return self.validation_result.error_count == 0
+
+    @property
+    def validation_score(self) -> int:
+        """Get validation quality score (0-100)."""
+        if self.validation_result is None:
+            return 100
+        return self.validation_result.quality_score
+
+
+@dataclass
+class StatusReport:
+    """Aggregated report containing all spec statuses and summary statistics.
+
+    Attributes:
+        specs: All parsed spec statuses
+        generated_at: Report generation timestamp
+        project_root: Root directory of the project
+    """
+
+    specs: list[SpecStatus] = field(default_factory=list)
+    generated_at: datetime = field(default_factory=datetime.now)
+    project_root: Path = field(default_factory=Path.cwd)
+
+    @property
+    def total_count(self) -> int:
+        """Total number of specs."""
+        return len(self.specs)
+
+    @property
+    def by_status(self) -> dict[SpecState, int]:
+        """Count of specs grouped by status."""
+        counts: dict[SpecState, int] = {state: 0 for state in SpecState}
+        for spec in self.specs:
+            counts[spec.status] = counts.get(spec.status, 0) + 1
+        return counts
+
+    @property
+    def blocking_count(self) -> int:
+        """Number of specs blocking commits."""
+        return sum(1 for spec in self.specs if spec.is_blocking)
+
+    @property
+    def validation_pass_count(self) -> int:
+        """Specs passing validation."""
+        return sum(1 for spec in self.specs if spec.validation_passed)
+
+    @property
+    def validation_fail_count(self) -> int:
+        """Specs failing validation."""
+        return sum(1 for spec in self.specs if not spec.validation_passed)
+
+    @property
+    def completion_percentage(self) -> float:
+        """Percentage of Complete + Approved specs."""
+        if self.total_count == 0:
+            return 0.0
+        complete_count = sum(
+            1
+            for spec in self.specs
+            if spec.status in (SpecState.COMPLETE, SpecState.APPROVED)
+        )
+        return (complete_count / self.total_count) * 100
+
+    @property
+    def is_ready_to_commit(self) -> bool:
+        """True if no blocking specs."""
+        return self.blocking_count == 0
+
+    @property
+    def draft_count(self) -> int:
+        """Number of draft specs."""
+        return self.by_status.get(SpecState.DRAFT, 0)
+
+    @property
+    def in_progress_count(self) -> int:
+        """Number of in-progress specs."""
+        return self.by_status.get(SpecState.IN_PROGRESS, 0)
+
+    @property
+    def complete_count(self) -> int:
+        """Number of complete specs."""
+        return self.by_status.get(SpecState.COMPLETE, 0)
+
+    @property
+    def approved_count(self) -> int:
+        """Number of approved specs."""
+        return self.by_status.get(SpecState.APPROVED, 0)

doit_cli/models/sync_models.py

@@ -0,0 +1,146 @@
+"""Data models for GitHub Copilot prompt synchronization."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+
+
+class SyncStatusEnum(str, Enum):
+    """Synchronization status between command and prompt."""
+
+    SYNCHRONIZED = "synchronized"
+    OUT_OF_SYNC = "out_of_sync"
+    MISSING = "missing"
+
+
+class OperationType(str, Enum):
+    """Type of file operation during sync."""
+
+    CREATED = "created"
+    UPDATED = "updated"
+    SKIPPED = "skipped"
+    FAILED = "failed"
+
+
+@dataclass
+class CommandTemplate:
+    """Represents a doit command template file in .doit/templates/commands/."""
+
+    name: str
+    path: Path
+    modified_at: datetime
+    description: str = ""
+    content: str = field(default="", repr=False)
+
+    @property
+    def prompt_filename(self) -> str:
+        """Generate the corresponding prompt filename."""
+        # doit.checkin.md -> doit.checkin.prompt.md
+        return f"{self.name}.prompt.md"
+
+    @classmethod
+    def from_path(cls, path: Path) -> "CommandTemplate":
+        """Create a CommandTemplate from a file path."""
+        content = path.read_text(encoding="utf-8")
+        modified_at = datetime.fromtimestamp(path.stat().st_mtime)
+
+        # Extract name from filename: doit.checkin.md -> doit.checkin
+        name = path.stem  # removes .md extension
+
+        # Extract description from YAML frontmatter
+        description = ""
+        if content.startswith("---"):
+            try:
+                end_idx = content.index("---", 3)
+                frontmatter = content[3:end_idx].strip()
+                for line in frontmatter.split("\n"):
+                    if line.startswith("description:"):
+                        description = line.replace("description:", "").strip()
+                        # Remove quotes if present
+                        description = description.strip("\"'")
+                        break
+            except ValueError:
+                pass  # No closing ---
+
+        return cls(
+            name=name,
+            path=path,
+            modified_at=modified_at,
+            description=description,
+            content=content,
+        )
+
+
+@dataclass
+class PromptFile:
+    """Represents a generated GitHub Copilot prompt file in .github/prompts/."""
+
+    name: str
+    path: Path
+    generated_at: datetime
+    content: str = field(default="", repr=False)
+
+    @classmethod
+    def from_path(cls, path: Path) -> "PromptFile":
+        """Create a PromptFile from an existing file path."""
+        content = path.read_text(encoding="utf-8")
+        generated_at = datetime.fromtimestamp(path.stat().st_mtime)
+
+        # Extract name from filename: doit.checkin.prompt.md -> doit.checkin.prompt
+        name = path.name.replace(".md", "")
+
+        return cls(
+            name=name,
+            path=path,
+            generated_at=generated_at,
+            content=content,
+        )
+
+
+@dataclass
+class SyncStatus:
+    """Represents the synchronization state between a command and its prompt."""
+
+    command_name: str
+    status: SyncStatusEnum
+    checked_at: datetime
+    reason: str = ""
+
+
+@dataclass
+class FileOperation:
+    """Represents a single file operation during sync."""
+
+    file_path: str
+    operation_type: OperationType
+    success: bool
+    message: str = ""
+
+
+@dataclass
+class SyncResult:
+    """Represents the result of a synchronization operation."""
+
+    total_commands: int = 0
+    synced: int = 0
+    skipped: int = 0
+    failed: int = 0
+    operations: list[FileOperation] = field(default_factory=list)
+
+    def add_operation(self, operation: FileOperation) -> None:
+        """Add a file operation to the result."""
+        self.operations.append(operation)
+        if operation.operation_type == OperationType.CREATED:
+            self.synced += 1
+        elif operation.operation_type == OperationType.UPDATED:
+            self.synced += 1
+        elif operation.operation_type == OperationType.SKIPPED:
+            self.skipped += 1
+        elif operation.operation_type == OperationType.FAILED:
+            self.failed += 1
+
+    @property
+    def success(self) -> bool:
+        """Check if sync completed without failures."""
+        return self.failed == 0

doit_cli/models/template.py

@@ -0,0 +1,77 @@
+"""Template model representing a bundled command template."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import hashlib
+
+from .agent import Agent
+
+
+# List of all doit command names (without extension/prefix)
+DOIT_COMMANDS = [
+    "checkin",
+    "constitution",
+    "documentit",
+    "fixit",
+    "implementit",
+    "planit",
+    "reviewit",
+    "roadmapit",
+    "scaffoldit",
+    "specit",
+    "taskit",
+    "testit",
+]
+
+
+@dataclass
+class Template:
+    """Represents a bundled command template."""
+
+    name: str
+    agent: Agent
+    source_path: Path
+    content: str = field(default="", repr=False)
+
+    @property
+    def content_hash(self) -> str:
+        """SHA-256 hash of template content (first 12 chars)."""
+        return hashlib.sha256(self.content.encode()).hexdigest()[:12]
+
+    @property
+    def target_filename(self) -> str:
+        """Filename for the generated command file."""
+        if self.agent == Agent.CLAUDE:
+            return f"doit.{self.name}.md"
+        else:  # COPILOT
+            return f"doit.{self.name}.prompt.md"
+
+    @classmethod
+    def from_file(cls, path: Path, agent: Agent) -> "Template":
+        """Create a Template from a file path."""
+        content = path.read_text(encoding="utf-8")
+
+        # Extract command name from filename
+        filename = path.name
+        if agent == Agent.CLAUDE:
+            # doit.specit.md -> specit
+            name = filename.replace("doit.", "").replace(".md", "")
+        else:  # COPILOT
+            # doit.specit.prompt.md -> specit
+            name = filename.replace("doit.", "").replace(".prompt.md", "")
+
+        return cls(name=name, agent=agent, source_path=path, content=content)
+
+    def matches_target(self, target_path: Path) -> bool:
+        """Check if target file exists and matches this template's content."""
+        if not target_path.exists():
+            return False
+
+        target_content = target_path.read_text(encoding="utf-8")
+        target_hash = hashlib.sha256(target_content.encode()).hexdigest()[:12]
+        return target_hash == self.content_hash
+
+
+def get_required_templates() -> list[str]:
+    """Return list of required template names."""
+    return DOIT_COMMANDS.copy()