misterdev 0.2.0__py3-none-any.whl

misterdev/core/modes.py

@@ -0,0 +1,184 @@
+"""Build mode system ported from /build skill.
+
+Determines operating mode from user input and project state.
+"""
+
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+
+class BuildMode(str, Enum):
+    DEBUG = "debug"
+    COMPLETE = "complete"
+    REVIEW = "review"
+    CREATE = "create"
+    SPEC = "spec"
+    AUTO = "auto"
+    SMART = "smart"
+
+
+class BuildFlags:
+    """Parsed flags from user input."""
+
+    def __init__(
+        self,
+        budget: float = 100.0,
+        commit: bool = False,
+        no_verify: bool = False,
+        no_suggest: bool = False,
+        dry_run: bool = False,
+        focus: Optional[str] = None,
+        interactive: bool = False,
+        parallel: bool = False,
+        no_rollback: bool = False,
+        allow_dirty: bool = False,
+        max_tasks: Optional[int] = None,
+    ):
+        self.budget = budget
+        self.commit = commit
+        self.no_verify = no_verify
+        self.no_suggest = no_suggest
+        self.dry_run = dry_run
+        self.focus = focus
+        self.interactive = interactive
+        self.parallel = parallel
+        self.no_rollback = no_rollback
+        self.allow_dirty = allow_dirty
+        # Per-run ceiling on decomposed tasks (CLI --max-tasks); None = use the
+        # config default. Bounds a focused run so a broad spec can't balloon into
+        # dozens of tasks and exhaust the budget.
+        self.max_tasks = max_tasks
+
+    def __repr__(self) -> str:
+        return (
+            f"BuildFlags(budget={self.budget}, commit={self.commit}, "
+            f"dry_run={self.dry_run}, focus={self.focus}, interactive={self.interactive})"
+        )
+
+
+def parse_flags(args: list[str]) -> tuple[list[str], BuildFlags]:
+    """Extract flags from args list, return (remaining_args, flags)."""
+    remaining = []
+    flags = BuildFlags()
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--budget" and i + 1 < len(args):
+            flags.budget = float(args[i + 1])
+            i += 2
+        elif arg == "--commit":
+            flags.commit = True
+            i += 1
+        elif arg == "--no-verify":
+            flags.no_verify = True
+            i += 1
+        elif arg == "--no-suggest":
+            flags.no_suggest = True
+            i += 1
+        elif arg == "--dry-run":
+            flags.dry_run = True
+            i += 1
+        elif arg == "--interactive" or arg == "-i":
+            flags.interactive = True
+            i += 1
+        elif arg == "--parallel":
+            flags.parallel = True
+            i += 1
+        elif arg == "--no-rollback":
+            flags.no_rollback = True
+            i += 1
+        elif arg == "--allow-dirty":
+            flags.allow_dirty = True
+            i += 1
+        elif arg == "--focus" and i + 1 < len(args):
+            flags.focus = args[i + 1]
+            i += 2
+        elif arg == "--max-tasks" and i + 1 < len(args):
+            try:
+                flags.max_tasks = int(args[i + 1])
+            except ValueError:
+                flags.max_tasks = None
+            i += 2
+        else:
+            remaining.append(arg)
+            i += 1
+    return remaining, flags
+
+
+def resolve_mode(prompt: str, project_path: Path) -> BuildMode:
+    """Determine build mode from prompt content and project state.
+
+    Resolution order (from /build skill):
+      - "debug"           -> DEBUG
+      - "complete"        -> COMPLETE
+      - "review"          -> REVIEW
+      - "new <desc>"      -> CREATE
+      - path to .md file  -> SPEC
+      - empty prompt      -> AUTO (project exists -> COMPLETE, else CREATE)
+      - anything else     -> SMART
+    """
+    stripped = prompt.strip().lower()
+
+    if stripped == "debug":
+        return BuildMode.DEBUG
+    if stripped == "complete":
+        return BuildMode.COMPLETE
+    if stripped == "review":
+        return BuildMode.REVIEW
+    if stripped.startswith("new "):
+        return BuildMode.CREATE
+
+    # Check if prompt is a path to an existing .md spec file
+    if prompt.strip().endswith(".md"):
+        spec_path = project_path / prompt.strip()
+        if spec_path.exists():
+            return BuildMode.SPEC
+
+    if not stripped:
+        # AUTO: detect from project state
+        has_code = _project_has_code(project_path)
+        return BuildMode.COMPLETE if has_code else BuildMode.CREATE
+
+    return BuildMode.SMART
+
+
+def _project_has_code(project_path: Path) -> bool:
+    """Check if a project directory contains source code files."""
+    code_extensions = {
+        ".py",
+        ".js",
+        ".ts",
+        ".rs",
+        ".go",
+        ".java",
+        ".c",
+        ".cpp",
+        ".rb",
+        ".php",
+        ".swift",
+        ".kt",
+        ".scala",
+        ".zig",
+    }
+    for item in project_path.rglob("*"):
+        if item.suffix in code_extensions and not _is_venv_or_vendor(item):
+            return True
+    return False
+
+
+def _is_venv_or_vendor(path: Path) -> bool:
+    """Exclude virtual environments and vendor directories."""
+    exclude_dirs = {
+        "venv",
+        ".venv",
+        "env",
+        "node_modules",
+        "vendor",
+        "__pycache__",
+        ".git",
+        "target",
+        "build",
+        "dist",
+    }
+    return any(part in exclude_dirs for part in path.parts)

misterdev/core/planning/advisor.py

@@ -0,0 +1,89 @@
+"""Work recommendation for interactive planning.
+
+Given a ProjectAssessment, ask the LLM to propose a short, ranked list of
+concrete work items it would recommend next. Used by the interactive planner
+so the orchestrator composes the plan from the project's live state instead of
+a predefined devplan.
+"""
+
+from dataclasses import dataclass
+from typing import List
+
+from misterdev.core.planning.assessment import ProjectAssessment
+from misterdev.llm.client import BaseLLMClient
+from misterdev.llm.responses import extract_json_array
+from misterdev.logging_setup import setup_logger
+
+logger = setup_logger(__name__)
+
+VALID_WORK_TYPES = {"debug", "complete", "feature", "refactor", "test", "docs"}
+
+RECOMMEND_PROMPT = """You are advising on what to work on next in this project.
+
+Project assessment:
+{summary}
+
+Incomplete features: {incomplete}
+Broken/stub code: {broken}
+Open TODO/FIXME: {todos}
+
+Propose 3-6 concrete, high-value work items, ranked best-first. Favor fixing
+what is broken and completing what is started over new features. Each item must
+be specific enough to act on (name the area or behavior), not a vague theme.
+
+Return ONLY a JSON array, each element:
+  {{"title": "...", "rationale": "one sentence why it matters now",
+    "work_type": "debug|complete|feature|refactor|test|docs"}}
+"""
+
+
+@dataclass
+class Recommendation:
+    title: str
+    rationale: str
+    work_type: str
+
+
+def recommend_work(
+    assessment: ProjectAssessment, llm_client: BaseLLMClient
+) -> List[Recommendation]:
+    """Return a ranked list of recommended work items, or [] on failure."""
+    features = assessment.features
+    prompt = RECOMMEND_PROMPT.format(
+        summary=assessment.summary(),
+        incomplete=_names(getattr(features, "incomplete", [])),
+        broken=_names(getattr(features, "broken", [])),
+        todos=len(getattr(features, "todos", []) or []),
+    )
+    try:
+        response = llm_client.generate_code(
+            prompt, "You are a pragmatic engineering lead. Return only JSON."
+        )
+    except Exception as e:
+        logger.error(f"Failed to generate recommendations: {e}")
+        return []
+    raw = extract_json_array(response)
+
+    recs: List[Recommendation] = []
+    for item in raw:
+        if not isinstance(item, dict) or not item.get("title"):
+            continue
+        wt = str(item.get("work_type", "complete")).lower()
+        if wt not in VALID_WORK_TYPES:
+            wt = "complete"
+        recs.append(
+            Recommendation(
+                title=str(item["title"]).strip(),
+                rationale=str(item.get("rationale", "")).strip(),
+                work_type=wt,
+            )
+        )
+    return recs
+
+
+def _names(items) -> str:
+    out = []
+    for it in items:
+        name = getattr(it, "name", None) or getattr(it, "title", None) or str(it)
+        out.append(str(name))
+    return ", ".join(out[:12]) if out else "none"

misterdev/core/planning/assessment.py

@@ -0,0 +1,135 @@
+"""Project assessment models ported from /build skill Phase 1.
+
+Structured representations of project analysis results used to drive
+all subsequent build phases.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Optional
+
+
+class _AssessmentModel(BaseModel):
+    """Base for the assessment models.
+
+    ``validate_assignment`` makes attribute writes (not just construction)
+    type-checked. The pipeline mutates these models field-by-field straight from
+    LLM JSON (see the analyzer's merge step), so without this a ``null`` or
+    wrong-typed write would be stored silently and only crash much later; with it
+    a bad write fails fast, at the assignment site.
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+
+class HealthCheck(_AssessmentModel):
+    """Result of running build, test, and lint commands."""
+
+    builds: bool = False
+    build_output: str = ""
+    tests_pass: bool = False
+    test_count: int = 0
+    test_failures: int = 0
+    test_output: str = ""
+    lint_clean: bool = False
+    lint_warnings: int = 0
+    lint_output: str = ""
+    missing_dependencies: list[str] = Field(default_factory=list)
+
+
+class FeatureInfo(_AssessmentModel):
+    """A single feature with evidence of its state."""
+
+    name: str
+    description: str = ""
+    evidence_files: list[str] = Field(default_factory=list)
+    complexity: str = "medium"  # trivial, small, medium, large, architectural
+
+
+class FeatureInventory(_AssessmentModel):
+    """Completeness analysis from /build Phase 1b."""
+
+    existing: list[FeatureInfo] = Field(default_factory=list)
+    incomplete: list[FeatureInfo] = Field(default_factory=list)
+    missing: list[FeatureInfo] = Field(default_factory=list)
+    dead_code: list[str] = Field(default_factory=list)
+    stubs: list[str] = Field(default_factory=list)
+    broken: list[str] = Field(default_factory=list)
+    todos: list[dict] = Field(default_factory=list)
+
+
+class ProjectStructure(_AssessmentModel):
+    """Structural profile from /build Phase 1a."""
+
+    project_type: str = "unknown"  # web-api, web-app, cli, library, etc.
+    languages: list[str] = Field(default_factory=list)
+    frameworks: list[str] = Field(default_factory=list)
+    build_system: Optional[str] = None
+    build_command: Optional[str] = None
+    test_system: Optional[str] = None
+    test_command: Optional[str] = None
+    lint_command: Optional[str] = None
+    package_manager: Optional[str] = None
+    entry_points: list[str] = Field(default_factory=list)
+    directory_structure: str = ""
+
+
+class ProjectContext(_AssessmentModel):
+    """Contextual information from /build Phase 1c."""
+
+    purpose: str = ""
+    goals: str = ""
+    conventions: str = ""
+    constraints: str = ""
+    recent_activity: str = ""
+    stated_requirements: str = ""
+    reference_impl: Optional[str] = None
+
+
+class TechnicalDebt(_AssessmentModel):
+    """Technical debt estimation from /build Phase 1."""
+
+    score: int = 0  # 0-100
+    description: str = ""
+    critical_issues: list[str] = Field(default_factory=list)
+
+
+class RiskAssessment(_AssessmentModel):
+    """Risk analysis for the proposed build."""
+
+    level: str = "low"  # low, medium, high, critical
+    factors: list[str] = Field(default_factory=list)
+    mitigations: list[str] = Field(default_factory=list)
+
+
+class ProjectAssessment(_AssessmentModel):
+    """Merged assessment from all Phase 1 agents.
+
+    This is the central data structure that drives Phases 2-6.
+    """
+
+    structure: ProjectStructure = Field(default_factory=ProjectStructure)
+    health: HealthCheck = Field(default_factory=HealthCheck)
+    features: FeatureInventory = Field(default_factory=FeatureInventory)
+    context: ProjectContext = Field(default_factory=ProjectContext)
+    tech_debt: TechnicalDebt = Field(default_factory=TechnicalDebt)
+    risk: RiskAssessment = Field(default_factory=RiskAssessment)
+
+    def summary(self) -> str:
+        """One-line summary for logging."""
+        s = self.structure
+        h = self.health
+        lang = ", ".join(s.languages) if s.languages else "unknown"
+        build_status = "OK" if h.builds else "FAIL"
+        # Clamp the passing count: some runner parsers fill test_count and
+        # test_failures from independent regexes, so a malformed log can yield
+        # failures > count, which would otherwise render a negative "passed".
+        test_status = (
+            f"{max(0, h.test_count - h.test_failures)}/{h.test_count}"
+            if h.test_count
+            else "none"
+        )
+        return (
+            f"[{s.project_type}] {lang} | "
+            f"build={build_status} tests={test_status} "
+            f"lint_warnings={h.lint_warnings}"
+        )