borisxdave 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

prompts.py

@@ -29,17 +29,32 @@ _boris_prompt_cache = None
 
 
 def _load_boris_prompt() -> str:
-    """Load Boris's management prompt from boris_prompt.md. Cached after first load."""
+    """Load Boris's management prompt from boris_prompt.md. Cached after first load.
+
+    Searches multiple locations to handle both editable installs (source dir)
+    and regular pip installs (site-packages).
+    """
     global _boris_prompt_cache
     if _boris_prompt_cache is not None:
         return _boris_prompt_cache
-    try:
-        with open(_BORIS_PROMPT_PATH, "r", encoding="utf-8") as f:
-            _boris_prompt_cache = f.read().strip()
-        logger.debug("Loaded Boris prompt: %d chars", len(_boris_prompt_cache))
-    except FileNotFoundError:
-        logger.warning("boris_prompt.md not found at %s", _BORIS_PROMPT_PATH)
-        _boris_prompt_cache = ""
+
+    search_paths = [
+        _BORIS_PROMPT_PATH,  # Next to this .py file (editable install / source)
+        os.path.join(sys.prefix, "boris_prompt.md"),  # sys.prefix (some data_files installs)
+        os.path.join(os.path.dirname(shutil.which("boris") or ""), "boris_prompt.md"),  # Next to boris script
+    ]
+
+    for path in search_paths:
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                _boris_prompt_cache = f.read().strip()
+            logger.debug("Loaded Boris prompt from %s (%d chars)", path, len(_boris_prompt_cache))
+            return _boris_prompt_cache
+        except (FileNotFoundError, OSError, TypeError):
+            continue
+
+    logger.warning("boris_prompt.md not found in any search path: %s", search_paths)
+    _boris_prompt_cache = ""
     return _boris_prompt_cache
 
 # Regex to strip ANSI escape codes
@@ -87,14 +102,45 @@ def _list_project_files(project_dir: str, max_files: int = 500) -> str:
 # --- Planning (from planner.py) ---
 
 
-def create_plan(task: str, project_dir: str) -> Plan:
-    """Break a task into milestones using Claude CLI."""
+def create_plan(task: str, project_dir: str, turbo: bool = False) -> Plan:
+    """Break a task into milestones using Claude CLI.
+
+    Args:
+        task: The task description.
+        project_dir: Path to the project directory.
+        turbo: When True, emphasize minimal dependencies and maximum parallelism.
+    """
     file_listing = _list_project_files(project_dir)
 
+    if turbo:
+        dependency_instructions = (
+            "CRITICAL DEPENDENCY RULES (turbo/parallel mode):\n"
+            "- Only add a dependency if the milestone TRULY requires output from another milestone to function.\n"
+            "- Two milestones that share a common dependency should NOT depend on each other unless one genuinely needs the other's output.\n"
+            "- Maximize parallelism in the dependency graph. Independent features, pages, or modules that share the same foundation should run in parallel.\n"
+            "- Do NOT chain milestones linearly unless there is a real data/code dependency between them.\n\n"
+            "Example of WRONG dependencies (overly sequential):\n"
+            '  M1: Project Setup (depends_on: [])\n'
+            '  M2: Auth Backend (depends_on: ["M1"])\n'
+            '  M3: Login Page (depends_on: ["M2"])\n'
+            '  M4: Dashboard Page (depends_on: ["M3"])  <-- WRONG: only needs M2, not M3\n'
+            '  M5: Profile Page (depends_on: ["M4"])    <-- WRONG: only needs M2, not M4\n\n'
+            "Example of CORRECT dependencies (maximizes parallelism):\n"
+            '  M1: Project Setup (depends_on: [])\n'
+            '  M2: Auth Backend (depends_on: ["M1"])\n'
+            '  M3: Login Page (depends_on: ["M2"])\n'
+            '  M4: Dashboard Page (depends_on: ["M2"])  <-- parallel with M3\n'
+            '  M5: Profile Page (depends_on: ["M2"])    <-- parallel with M3, M4\n\n'
+        )
+    else:
+        dependency_instructions = (
+            "Order by dependency: foundation first, then features that depend on it.\n"
+        )
+
     prompt = (
         "You are a technical project planner. Break this task into ordered milestones.\n"
         "Each milestone must be a concrete, buildable unit that DaveLoop can execute independently.\n"
-        "Order by dependency: foundation first, then features that depend on it.\n\n"
+        f"{dependency_instructions}\n"
         f"Task: {task}\n"
         f"Project directory: {project_dir}\n"
         f"Existing files:\n{file_listing}\n\n"
@@ -279,14 +325,116 @@ def _save_plan_markdown(plan: Plan, task: str) -> str:
     return filepath
 
 
+def load_plan_from_file(filepath: str) -> Plan:
+    """Parse a saved plan markdown file back into a Plan object.
+
+    Reads the markdown format produced by _save_plan_markdown and reconstructs
+    the Plan with its Milestone objects.
+    """
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"Plan file not found: {filepath}")
+
+    with open(filepath, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # Extract task from **Task:** line
+    task_match = re.search(r"\*\*Task:\*\*\s*(.+)", content)
+    task = task_match.group(1).strip() if task_match else "Unknown task"
+
+    # Extract created_at from **Created:** line
+    created_match = re.search(r"\*\*Created:\*\*\s*(.+)", content)
+    created_at = created_match.group(1).strip() if created_match else datetime.now().isoformat()
+
+    # Split into milestone sections by ## M<N>: headers
+    milestone_sections = re.split(r"(?=^## M\d+:)", content, flags=re.MULTILINE)
+
+    milestones = []
+    for section in milestone_sections:
+        # Only process sections that start with a milestone header
+        header_match = re.match(r"^## (M\d+):\s*(.+)", section)
+        if not header_match:
+            continue
+
+        m_id = header_match.group(1)
+        m_title = header_match.group(2).strip()
+
+        # Extract description: text between the header and the first **bold** field or ---
+        # Skip the header line, then collect lines until we hit a **field:** or ---
+        lines = section.split("\n")
+        desc_lines = []
+        in_desc = False
+        for line in lines[1:]:  # skip header line
+            stripped = line.strip()
+            if not stripped:
+                if in_desc:
+                    desc_lines.append("")
+                continue
+            if stripped.startswith("**") or stripped == "---":
+                break
+            desc_lines.append(stripped)
+            in_desc = True
+        description = "\n".join(desc_lines).strip()
+
+        # Extract depends_on
+        depends_match = re.search(r"\*\*Depends on:\*\*\s*(.+)", section)
+        depends_on = []
+        if depends_match:
+            deps_str = depends_match.group(1).strip()
+            depends_on = [d.strip() for d in deps_str.split(",") if d.strip()]
+
+        # Extract acceptance criteria (bulleted list after **Acceptance Criteria:**)
+        criteria = []
+        criteria_match = re.search(r"\*\*Acceptance Criteria:\*\*\s*\n((?:\s*- .+\n?)+)", section)
+        if criteria_match:
+            for line in criteria_match.group(1).strip().split("\n"):
+                line = line.strip()
+                if line.startswith("- "):
+                    criteria.append(line[2:].strip())
+
+        # Extract files to create
+        files_create_match = re.search(r"\*\*Files to create:\*\*\s*(.+)", section)
+        files_to_create = []
+        if files_create_match:
+            files_to_create = [f.strip() for f in files_create_match.group(1).split(",") if f.strip()]
+
+        # Extract files to modify
+        files_modify_match = re.search(r"\*\*Files to modify:\*\*\s*(.+)", section)
+        files_to_modify = []
+        if files_modify_match:
+            files_to_modify = [f.strip() for f in files_modify_match.group(1).split(",") if f.strip()]
+
+        milestones.append(Milestone(
+            id=m_id,
+            title=m_title,
+            description=description,
+            depends_on=depends_on,
+            acceptance_criteria=criteria,
+            files_to_create=files_to_create,
+            files_to_modify=files_to_modify,
+        ))
+
+    if not milestones:
+        raise RuntimeError(f"No milestones found in plan file: {filepath}")
+
+    return Plan(task=task, milestones=milestones, created_at=created_at)
+
+
 # --- Prompt Crafting (from crafter.py) ---
 
 
-def craft_prompt(milestone: Milestone, plan: Plan, project_dir: str) -> str:
+def craft_prompt(milestone: Milestone, plan: Plan, project_dir: str,
+                  turbo: bool = False, sibling_milestones: list[Milestone] | None = None) -> str:
     """Build a detailed prompt for DaveLoop to execute a milestone.
 
     This is the most critical function in Boris. DaveLoop needs everything
     in ONE prompt - context, spec, integration points, acceptance criteria.
+
+    Args:
+        milestone: The milestone to build a prompt for.
+        plan: The full plan for context.
+        project_dir: Path to the project directory.
+        turbo: When True, adds parallel execution warnings.
+        sibling_milestones: Other milestones running concurrently in the same turbo batch.
     """
     sections = []
 
@@ -305,6 +453,37 @@ def craft_prompt(milestone: Milestone, plan: Plan, project_dir: str) -> str:
         sections.append("**Do NOT create or modify any other files.**")
         sections.append("")
 
+    # Turbo mode: parallel execution warning
+    if turbo and sibling_milestones:
+        sections.append("## PARALLEL EXECUTION WARNING")
+        sections.append("")
+        sections.append("**You are running in PARALLEL with other DaveLoops.** Other milestones")
+        sections.append("are being built AT THE SAME TIME by sibling DaveLoop processes.")
+        sections.append("Modifying files outside your scope WILL cause conflicts or silent overwrites.")
+        sections.append("")
+        sections.append("**Sibling milestones running concurrently:**")
+        for sib in sibling_milestones:
+            sib_files = (sib.files_to_create or []) + (sib.files_to_modify or [])
+            sib_files_str = ", ".join(sib_files) if sib_files else "(no specific files)"
+            sections.append(f"- **{sib.id}: {sib.title}** - Files: {sib_files_str}")
+        sections.append("")
+        # Collect all sibling files into a flat list for the explicit prohibition
+        all_sibling_files = []
+        for sib in sibling_milestones:
+            all_sibling_files.extend(sib.files_to_create or [])
+            all_sibling_files.extend(sib.files_to_modify or [])
+        if all_sibling_files:
+            unique_sibling_files = sorted(set(all_sibling_files))
+            sections.append("**DO NOT touch these files (owned by sibling milestones):**")
+            for sf in unique_sibling_files:
+                sections.append(f"- {sf}")
+            sections.append("")
+        sections.append("**Rules:**")
+        sections.append("1. ONLY modify files listed in YOUR files_to_create/files_to_modify scope above.")
+        sections.append("2. Do NOT modify shared config files (package.json, routing tables, etc.) unless they are explicitly in YOUR scope.")
+        sections.append("3. If you need a shared file changed, add a TODO comment instead of editing it.")
+        sections.append("")
+
     # What to build
     sections.append(f"## What to Build")
     sections.append(milestone.description)

state.py

@@ -63,16 +63,96 @@ class State:
     updated_at: str = field(default_factory=lambda: datetime.now().isoformat())
     phase: str = "structural"  # structural | ui_testing
     ui_plan: Optional[UIPlan] = None
+    turbo: bool = False
 
 
 def save(state: State) -> None:
-    """Save state to {project_dir}/.boris/state.json."""
+    """Save state to {project_dir}/.boris/state.json and plan.md."""
     state_dir = os.path.join(state.project_dir, config.STATE_DIR)
     os.makedirs(state_dir, exist_ok=True)
     state_path = os.path.join(state_dir, config.STATE_FILE)
     state.updated_at = datetime.now().isoformat()
     with open(state_path, "w", encoding="utf-8") as f:
         json.dump(asdict(state), f, indent=2, ensure_ascii=False)
+    # Also export a human-readable markdown plan
+    _save_plan_md(state)
+
+
+def _save_plan_md(state: State) -> None:
+    """Export the plan as a readable markdown file in the project directory."""
+    plan = state.plan
+    if not plan or not plan.milestones:
+        return
+
+    status_icon = {
+        "completed": "[x]",
+        "in_progress": "[-]",
+        "skipped": "[~]",
+        "pending": "[ ]",
+    }
+
+    lines = []
+    lines.append(f"# Boris Plan")
+    lines.append("")
+    lines.append(f"**Task:** {plan.task}")
+    lines.append(f"**Created:** {plan.created_at}")
+    lines.append(f"**Updated:** {state.updated_at}")
+    lines.append(f"**Mode:** {'Turbo (parallel)' if state.turbo else 'Sequential'}")
+    lines.append("")
+
+    # Summary counts
+    counts = {}
+    for m in plan.milestones:
+        counts[m.status] = counts.get(m.status, 0) + 1
+    total = len(plan.milestones)
+    done = counts.get("completed", 0)
+    lines.append(f"**Progress:** {done}/{total} milestones completed")
+    if counts.get("skipped", 0):
+        lines.append(f"**Skipped:** {counts['skipped']}")
+    lines.append("")
+    lines.append("---")
+    lines.append("")
+
+    # Milestone list
+    lines.append("## Milestones")
+    lines.append("")
+    for m in plan.milestones:
+        icon = status_icon.get(m.status, "[ ]")
+        lines.append(f"### {icon} {m.id}: {m.title}")
+        lines.append("")
+        if m.depends_on:
+            lines.append(f"**Depends on:** {', '.join(m.depends_on)}")
+        lines.append(f"**Status:** {m.status}")
+        if m.completed_at:
+            lines.append(f"**Completed:** {m.completed_at}")
+        lines.append("")
+        lines.append(m.description)
+        lines.append("")
+
+        if m.acceptance_criteria:
+            lines.append("**Acceptance Criteria:**")
+            for ac in m.acceptance_criteria:
+                lines.append(f"- {ac}")
+            lines.append("")
+
+        if m.files_to_create:
+            lines.append(f"**Files to create:** {len(m.files_to_create)}")
+            for f_path in m.files_to_create:
+                lines.append(f"- `{f_path}`")
+            lines.append("")
+
+        if m.files_to_modify:
+            lines.append(f"**Files to modify:** {len(m.files_to_modify)}")
+            for f_path in m.files_to_modify:
+                lines.append(f"- `{f_path}`")
+            lines.append("")
+
+        lines.append("---")
+        lines.append("")
+
+    md_path = os.path.join(state.project_dir, config.STATE_DIR, "plan.md")
+    with open(md_path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))
 
 
 def load(project_dir: str) -> Optional[State]:
@@ -98,6 +178,7 @@ def load(project_dir: str) -> Optional[State]:
             no_git=data.get("no_git", False),
             started_at=data.get("started_at", ""),
             updated_at=data.get("updated_at", ""),
+            turbo=data.get("turbo", False),
         )
     except (json.JSONDecodeError, KeyError, TypeError):
         return None

borisxdave-0.2.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-boris.py,sha256=0AvcqWPhvfoR1U8zUGhcnCJImpcy8cITcD4zzJpx9Jk,28715
-config.py,sha256=KfFKyCGasdm1yBvIRFv-ykzA_oRo-zu1Euu9YC7V1Cg,324
-engine.py,sha256=PGRtbnsvr6egikqo0ENpA8WnXKdQ1kW2XWUFgJ-AXzk,26889
-git_manager.py,sha256=BuuTT4naPb5-jLhOik1xHM2ztzuKvJ_bnecZmlYgwFs,8493
-planner.py,sha256=HHrw2lpcZhRBzmCapk8Uw8ivUpB7fSz2V6_FaJLHlU4,5297
-prompts.py,sha256=6QHAftDjDqk_e2WCq5NkTH5Jd41PgFk68fkg4nMsy-Q,26228
-state.py,sha256=erggbuwJu-Ks6Y7hLQpFwIEN4LjqzBPpy8kTLZtk0ZM,3092
-borisxdave-0.2.0.dist-info/METADATA,sha256=adf_nOv8TymIA4ez-Hb7EEzzDXaFkAmVMJ512pY21Po,133
-borisxdave-0.2.0.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
-borisxdave-0.2.0.dist-info/entry_points.txt,sha256=fuO7JxKFLOm6xp6m3JHRA1UO_QW1dYU-F0IooA1NqQs,37
-borisxdave-0.2.0.dist-info/top_level.txt,sha256=zNzzkbLJWzWpTjJTQsnbdOBypcA4XpioE1dEgWZVBx4,54
-borisxdave-0.2.0.dist-info/RECORD,,