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

doit_cli/models/fixit_models.py

@@ -0,0 +1,355 @@
+"""Data models for bug-fix workflow.
+
+This module contains all data models, enums, and dataclasses
+for the doit fixit command workflow.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+
+# =============================================================================
+# Enums (T004-T007)
+# =============================================================================
+
+
+class FixPhase(Enum):
+    """Workflow phase states for bug-fix workflow."""
+
+    INITIALIZED = "initialized"
+    INVESTIGATING = "investigating"
+    PLANNING = "planning"
+    REVIEWING = "reviewing"
+    APPROVED = "approved"
+    IMPLEMENTING = "implementing"
+    COMPLETED = "completed"
+    CANCELLED = "cancelled"
+
+
+class FindingType(Enum):
+    """Types of investigation findings."""
+
+    HYPOTHESIS = "hypothesis"
+    CONFIRMED_CAUSE = "confirmed_cause"
+    AFFECTED_FILE = "affected_file"
+    REPRODUCTION_STEP = "reproduction_step"
+    RELATED_COMMIT = "related_commit"
+
+
+class RiskLevel(Enum):
+    """Risk levels for fix plans."""
+
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class PlanStatus(Enum):
+    """Status states for fix plans."""
+
+    DRAFT = "draft"
+    PENDING_REVIEW = "pending_review"
+    REVISION_NEEDED = "revision_needed"
+    APPROVED = "approved"
+
+
+class IssueState(Enum):
+    """GitHub issue states."""
+
+    OPEN = "open"
+    CLOSED = "closed"
+
+
+class ChangeType(Enum):
+    """Types of file changes in fix plans."""
+
+    MODIFY = "modify"
+    ADD = "add"
+    DELETE = "delete"
+
+
+# =============================================================================
+# Models (T008-T011)
+# =============================================================================
+
+
+@dataclass
+class GitHubIssue:
+    """Represents a GitHub issue fetched from the repository."""
+
+    number: int
+    title: str
+    body: str = ""
+    state: IssueState = IssueState.OPEN
+    labels: list[str] = field(default_factory=list)
+    created_at: Optional[datetime] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GitHubIssue":
+        """Create GitHubIssue from gh CLI JSON output."""
+        state = IssueState(data.get("state", "open").lower())
+        labels = [label["name"] if isinstance(label, dict) else label
+                  for label in data.get("labels", [])]
+        return cls(
+            number=data["number"],
+            title=data["title"],
+            body=data.get("body", "") or "",
+            state=state,
+            labels=labels,
+            created_at=None,  # Can be parsed from data if needed
+        )
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "number": self.number,
+            "title": self.title,
+            "body": self.body,
+            "state": self.state.value,
+            "labels": self.labels,
+        }
+
+
+@dataclass
+class FixWorkflow:
+    """Represents an in-progress bug fix workflow with its current phase and state."""
+
+    id: str
+    issue_id: int
+    branch_name: str
+    phase: FixPhase = FixPhase.INITIALIZED
+    started_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "issue_id": self.issue_id,
+            "branch_name": self.branch_name,
+            "phase": self.phase.value,
+            "started_at": self.started_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "FixWorkflow":
+        """Create FixWorkflow from dictionary."""
+        return cls(
+            id=data["id"],
+            issue_id=data["issue_id"],
+            branch_name=data["branch_name"],
+            phase=FixPhase(data["phase"]),
+            started_at=datetime.fromisoformat(data["started_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )
+
+
+@dataclass
+class InvestigationFinding:
+    """A discovered fact during investigation."""
+
+    id: str
+    finding_type: FindingType
+    description: str
+    evidence: str = ""
+    file_path: Optional[str] = None
+    line_number: Optional[int] = None
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "type": self.finding_type.value,
+            "description": self.description,
+            "evidence": self.evidence,
+            "file_path": self.file_path,
+            "line_number": self.line_number,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InvestigationFinding":
+        """Create InvestigationFinding from dictionary."""
+        return cls(
+            id=data["id"],
+            finding_type=FindingType(data["type"]),
+            description=data["description"],
+            evidence=data.get("evidence", ""),
+            file_path=data.get("file_path"),
+            line_number=data.get("line_number"),
+        )
+
+
+@dataclass
+class InvestigationCheckpoint:
+    """Tracks progress through investigation steps."""
+
+    id: str
+    title: str
+    completed: bool = False
+    notes: str = ""
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "title": self.title,
+            "completed": self.completed,
+            "notes": self.notes,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InvestigationCheckpoint":
+        """Create InvestigationCheckpoint from dictionary."""
+        return cls(
+            id=data["id"],
+            title=data["title"],
+            completed=data.get("completed", False),
+            notes=data.get("notes", ""),
+        )
+
+
+@dataclass
+class InvestigationPlan:
+    """Documents the approach for investigating a bug."""
+
+    id: str
+    workflow_id: str
+    keywords: list[str] = field(default_factory=list)
+    checkpoints: list[InvestigationCheckpoint] = field(default_factory=list)
+    findings: list[InvestigationFinding] = field(default_factory=list)
+    created_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "workflow_id": self.workflow_id,
+            "keywords": self.keywords,
+            "checkpoints": [cp.to_dict() for cp in self.checkpoints],
+            "findings": [f.to_dict() for f in self.findings],
+            "created_at": self.created_at.isoformat(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InvestigationPlan":
+        """Create InvestigationPlan from dictionary."""
+        return cls(
+            id=data["id"],
+            workflow_id=data["workflow_id"],
+            keywords=data.get("keywords", []),
+            checkpoints=[InvestigationCheckpoint.from_dict(cp)
+                        for cp in data.get("checkpoints", [])],
+            findings=[InvestigationFinding.from_dict(f)
+                     for f in data.get("findings", [])],
+            created_at=datetime.fromisoformat(data["created_at"])
+                       if "created_at" in data else datetime.now(),
+        )
+
+
+@dataclass
+class FileChange:
+    """Describes a file modification in a fix plan."""
+
+    file_path: str
+    change_type: ChangeType
+    description: str
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "file_path": self.file_path,
+            "change_type": self.change_type.value,
+            "description": self.description,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "FileChange":
+        """Create FileChange from dictionary."""
+        return cls(
+            file_path=data["file_path"],
+            change_type=ChangeType(data["change_type"]),
+            description=data["description"],
+        )
+
+
+@dataclass
+class FixPlan:
+    """Documents the approved approach to fix the bug."""
+
+    id: str
+    workflow_id: str
+    root_cause: str = ""
+    proposed_solution: str = ""
+    risk_level: RiskLevel = RiskLevel.LOW
+    status: PlanStatus = PlanStatus.DRAFT
+    affected_files: list[FileChange] = field(default_factory=list)
+    created_at: datetime = field(default_factory=datetime.now)
+    approved_at: Optional[datetime] = None
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "workflow_id": self.workflow_id,
+            "root_cause": self.root_cause,
+            "proposed_solution": self.proposed_solution,
+            "risk_level": self.risk_level.value,
+            "status": self.status.value,
+            "affected_files": [f.to_dict() for f in self.affected_files],
+            "created_at": self.created_at.isoformat(),
+            "approved_at": self.approved_at.isoformat() if self.approved_at else None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "FixPlan":
+        """Create FixPlan from dictionary."""
+        return cls(
+            id=data["id"],
+            workflow_id=data["workflow_id"],
+            root_cause=data.get("root_cause", ""),
+            proposed_solution=data.get("proposed_solution", ""),
+            risk_level=RiskLevel(data.get("risk_level", "low")),
+            status=PlanStatus(data.get("status", "draft")),
+            affected_files=[FileChange.from_dict(f)
+                           for f in data.get("affected_files", [])],
+            created_at=datetime.fromisoformat(data["created_at"])
+                       if "created_at" in data else datetime.now(),
+            approved_at=datetime.fromisoformat(data["approved_at"])
+                       if data.get("approved_at") else None,
+        )
+
+
+@dataclass
+class FixitWorkflowState:
+    """Complete state for a fixit workflow, used for persistence."""
+
+    workflow: FixWorkflow
+    issue: Optional[GitHubIssue] = None
+    investigation_plan: Optional[InvestigationPlan] = None
+    fix_plan: Optional[FixPlan] = None
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "workflow": self.workflow.to_dict(),
+            "issue": self.issue.to_dict() if self.issue else None,
+            "investigation_plan": self.investigation_plan.to_dict()
+                                 if self.investigation_plan else None,
+            "fix_plan": self.fix_plan.to_dict() if self.fix_plan else None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "FixitWorkflowState":
+        """Create FixitWorkflowState from dictionary."""
+        return cls(
+            workflow=FixWorkflow.from_dict(data["workflow"]),
+            issue=GitHubIssue.from_dict(data["issue"])
+                  if data.get("issue") else None,
+            investigation_plan=InvestigationPlan.from_dict(data["investigation_plan"])
+                              if data.get("investigation_plan") else None,
+            fix_plan=FixPlan.from_dict(data["fix_plan"])
+                    if data.get("fix_plan") else None,
+        )

doit_cli/models/hook_config.py

@@ -0,0 +1,125 @@
+"""Hook configuration models for workflow enforcement."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+@dataclass
+class HookRule:
+    """Configuration for a specific hook type."""
+
+    enabled: bool = True
+    require_spec: bool = True
+    require_plan: bool = True
+    require_tasks: bool = False
+    validate_spec: bool = True  # Run spec validation rules
+    validate_spec_threshold: int = 70  # Minimum quality score to pass
+    allowed_statuses: list[str] = field(
+        default_factory=lambda: ["In Progress", "Complete", "Approved"]
+    )
+    exempt_branches: list[str] = field(
+        default_factory=lambda: ["main", "develop"]
+    )
+    exempt_paths: list[str] = field(default_factory=list)
+
+
+@dataclass
+class LoggingConfig:
+    """Configuration for hook logging."""
+
+    enabled: bool = True
+    log_bypasses: bool = True
+    log_path: str = ".doit/logs/hook-bypasses.log"
+
+
+@dataclass
+class HookConfig:
+    """Main configuration for Git hooks workflow enforcement."""
+
+    version: int = 1
+    pre_commit: HookRule = field(default_factory=HookRule)
+    pre_push: HookRule = field(default_factory=HookRule)
+    logging: LoggingConfig = field(default_factory=LoggingConfig)
+
+    @classmethod
+    def load_from_file(cls, config_path: Path) -> "HookConfig":
+        """Load configuration from YAML file.
+
+        Args:
+            config_path: Path to the hooks.yaml configuration file.
+
+        Returns:
+            HookConfig instance with values from file or defaults.
+        """
+        if not config_path.exists():
+            return cls()
+
+        try:
+            with open(config_path, encoding="utf-8") as f:
+                data = yaml.safe_load(f) or {}
+        except yaml.YAMLError:
+            # Return default config on parse error
+            return cls()
+
+        return cls._from_dict(data)
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> "HookConfig":
+        """Create HookConfig from dictionary."""
+        pre_commit_data = data.get("pre_commit", {})
+        pre_push_data = data.get("pre_push", {})
+        logging_data = data.get("logging", {})
+
+        # Handle alternate key names
+        if "require_spec_status" in pre_commit_data:
+            pre_commit_data["allowed_statuses"] = pre_commit_data.pop(
+                "require_spec_status"
+            )
+        if "require_spec_status" in pre_push_data:
+            pre_push_data["allowed_statuses"] = pre_push_data.pop(
+                "require_spec_status"
+            )
+
+        return cls(
+            version=data.get("version", 1),
+            pre_commit=HookRule(**{
+                k: v for k, v in pre_commit_data.items()
+                if k in HookRule.__dataclass_fields__
+            }) if pre_commit_data else HookRule(),
+            pre_push=HookRule(**{
+                k: v for k, v in pre_push_data.items()
+                if k in HookRule.__dataclass_fields__
+            }) if pre_push_data else HookRule(),
+            logging=LoggingConfig(**{
+                k: v for k, v in logging_data.items()
+                if k in LoggingConfig.__dataclass_fields__
+            }) if logging_data else LoggingConfig(),
+        )
+
+    @classmethod
+    def get_default_config_path(cls) -> Path:
+        """Get the default configuration file path."""
+        return Path(".doit/config/hooks.yaml")
+
+    @classmethod
+    def load_default(cls) -> "HookConfig":
+        """Load configuration from default location."""
+        return cls.load_from_file(cls.get_default_config_path())
+
+    def get_rule_for_hook(self, hook_type: str) -> Optional[HookRule]:
+        """Get the rule configuration for a specific hook type.
+
+        Args:
+            hook_type: Type of hook ('pre-commit' or 'pre-push').
+
+        Returns:
+            HookRule for the specified hook type, or None if invalid.
+        """
+        hook_map = {
+            "pre-commit": self.pre_commit,
+            "pre-push": self.pre_push,
+        }
+        return hook_map.get(hook_type)

doit_cli/models/project.py

@@ -0,0 +1,91 @@
+"""Project model representing a directory being initialized for doit workflow."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from .agent import Agent
+
+
+# Unsafe paths that require confirmation before initialization
+UNSAFE_PATHS = [
+    Path.home(),
+    Path("/"),
+    Path("/usr"),
+    Path("/etc"),
+    Path("/var"),
+    Path("/opt"),
+    Path("/bin"),
+    Path("/sbin"),
+]
+
+
+@dataclass
+class Project:
+    """Represents a project being initialized for doit workflow."""
+
+    path: Path
+    initialized: bool = False
+    doit_version: Optional[str] = None
+    created_at: Optional[datetime] = None
+    agents: list[Agent] = field(default_factory=list)
+
+    @property
+    def doit_folder(self) -> Path:
+        """Path to .doit/ directory."""
+        return self.path / ".doit"
+
+    @property
+    def memory_folder(self) -> Path:
+        """Path to .doit/memory/ directory."""
+        return self.doit_folder / "memory"
+
+    @property
+    def templates_folder(self) -> Path:
+        """Path to .doit/templates/ directory."""
+        return self.doit_folder / "templates"
+
+    @property
+    def scripts_folder(self) -> Path:
+        """Path to .doit/scripts/ directory."""
+        return self.doit_folder / "scripts"
+
+    @property
+    def backups_folder(self) -> Path:
+        """Path to .doit/backups/ directory."""
+        return self.doit_folder / "backups"
+
+    def command_directory(self, agent: Agent) -> Path:
+        """Path to command directory for given agent."""
+        return self.path / agent.command_directory
+
+    def is_safe_directory(self) -> bool:
+        """Check if project path is safe for initialization."""
+        resolved = self.path.resolve()
+        return resolved not in UNSAFE_PATHS
+
+    def has_doit_setup(self) -> bool:
+        """Check if project has any doit setup."""
+        return self.doit_folder.exists()
+
+    def has_agent_setup(self, agent: Agent) -> bool:
+        """Check if project has setup for specific agent."""
+        return self.command_directory(agent).exists()
+
+    def detect_agents(self) -> list[Agent]:
+        """Detect which agents are already configured in this project."""
+        detected = []
+
+        # Check for Claude setup
+        claude_dir = self.path / ".claude"
+        if claude_dir.exists():
+            detected.append(Agent.CLAUDE)
+
+        # Check for Copilot setup
+        copilot_instructions = self.path / ".github" / "copilot-instructions.md"
+        copilot_prompts = self.path / ".github" / "prompts"
+        if copilot_instructions.exists() or copilot_prompts.exists():
+            detected.append(Agent.COPILOT)
+
+        return detected

doit_cli/models/results.py

@@ -0,0 +1,121 @@
+"""Result models for init and verify operations."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+from .project import Project
+
+
+class VerifyStatus(str, Enum):
+    """Status of verification check."""
+
+    PASS = "pass"
+    WARN = "warn"
+    FAIL = "fail"
+
+
+@dataclass
+class VerifyCheck:
+    """Single verification check result."""
+
+    name: str
+    status: VerifyStatus
+    message: str
+    suggestion: Optional[str] = None
+
+
+@dataclass
+class InitResult:
+    """Result of initialization operation."""
+
+    success: bool
+    project: Project
+    created_directories: list[Path] = field(default_factory=list)
+    created_files: list[Path] = field(default_factory=list)
+    updated_files: list[Path] = field(default_factory=list)
+    skipped_files: list[Path] = field(default_factory=list)
+    backup_path: Optional[Path] = None
+    error_message: Optional[str] = None
+
+    @property
+    def total_created(self) -> int:
+        """Total number of files and directories created."""
+        return len(self.created_directories) + len(self.created_files)
+
+    @property
+    def summary(self) -> str:
+        """Human-readable summary of the operation."""
+        if not self.success:
+            return f"Failed: {self.error_message or 'Unknown error'}"
+
+        parts = []
+        if self.created_directories:
+            parts.append(f"{len(self.created_directories)} directories created")
+        if self.created_files:
+            parts.append(f"{len(self.created_files)} files created")
+        if self.updated_files:
+            parts.append(f"{len(self.updated_files)} files updated")
+        if self.skipped_files:
+            parts.append(f"{len(self.skipped_files)} files skipped")
+
+        return ", ".join(parts) if parts else "No changes made"
+
+
+@dataclass
+class VerifyResult:
+    """Result of project verification."""
+
+    project: Project
+    checks: list[VerifyCheck] = field(default_factory=list)
+
+    @property
+    def passed(self) -> bool:
+        """All checks passed (no failures)."""
+        return not any(c.status == VerifyStatus.FAIL for c in self.checks)
+
+    @property
+    def has_warnings(self) -> bool:
+        """Any checks have warnings."""
+        return any(c.status == VerifyStatus.WARN for c in self.checks)
+
+    @property
+    def pass_count(self) -> int:
+        """Number of passed checks."""
+        return sum(1 for c in self.checks if c.status == VerifyStatus.PASS)
+
+    @property
+    def warn_count(self) -> int:
+        """Number of warning checks."""
+        return sum(1 for c in self.checks if c.status == VerifyStatus.WARN)
+
+    @property
+    def fail_count(self) -> int:
+        """Number of failed checks."""
+        return sum(1 for c in self.checks if c.status == VerifyStatus.FAIL)
+
+    @property
+    def summary(self) -> str:
+        """Summary of check results."""
+        return f"{self.pass_count} passed, {self.warn_count} warnings, {self.fail_count} failed"
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON output."""
+        return {
+            "status": "passed" if self.passed else "failed",
+            "checks": [
+                {
+                    "name": c.name,
+                    "status": c.status.value,
+                    "message": c.message,
+                    "suggestion": c.suggestion,
+                }
+                for c in self.checks
+            ],
+            "summary": {
+                "passed": self.pass_count,
+                "warnings": self.warn_count,
+                "failed": self.fail_count,
+            },
+        }