borisxdave 0.2.0__py3-none-any.whl

git_manager.py

@@ -0,0 +1,248 @@
+"""Boris git manager - git operations for milestone tracking."""
+import logging
+import subprocess
+import sys
+
+from state import Milestone
+
+# Git constants (inlined from config.py)
+GIT_COMMIT_PREFIX = "feat"
+GIT_PUSH_RETRIES = 1
+
+IS_WINDOWS = sys.platform == "win32"
+
+# Common kwargs for all git subprocess calls on Windows
+_SUBPROCESS_ENCODING = {"encoding": "utf-8", "errors": "replace"}
+
+logger = logging.getLogger("boris.git_manager")
+
+
+def ensure_git_config(project_dir: str) -> bool:
+    """Verify git user.name and user.email are configured. Sets defaults if missing.
+
+    Returns True if config is ready (either already set or defaults applied).
+    """
+    config_ok = True
+    for key, default in [("user.name", "Boris Orchestrator"), ("user.email", "boris@localhost")]:
+        try:
+            result = subprocess.run(
+                ["git", "config", key],
+                cwd=project_dir,
+                capture_output=True,
+                text=True,
+                **_SUBPROCESS_ENCODING,
+            )
+            if result.returncode != 0 or not result.stdout.strip():
+                logger.warning("Git config '%s' not set. Setting default: %s", key, default)
+                set_result = subprocess.run(
+                    ["git", "config", key, default],
+                    cwd=project_dir,
+                    capture_output=True,
+                    text=True,
+                    **_SUBPROCESS_ENCODING,
+                )
+                if set_result.returncode != 0:
+                    logger.error("Failed to set git config '%s': %s", key, set_result.stderr)
+                    config_ok = False
+                else:
+                    logger.info("Set git config '%s' = '%s'", key, default)
+            else:
+                logger.debug("Git config '%s' already set: %s", key, result.stdout.strip())
+        except (subprocess.SubprocessError, FileNotFoundError) as e:
+            logger.error("Error checking git config '%s': %s", key, e)
+            config_ok = False
+    return config_ok
+
+
+def init_repo(project_dir: str) -> bool:
+    """Initialize git repo if not already one. Returns success."""
+    try:
+        # Check if already a git repo
+        result = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            **_SUBPROCESS_ENCODING,
+        )
+        if result.returncode == 0:
+            logger.info("Git repo already initialized in %s", project_dir)
+            return True
+
+        # Initialize new repo
+        result = subprocess.run(
+            ["git", "init"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            **_SUBPROCESS_ENCODING,
+        )
+        if result.returncode == 0:
+            logger.info("Initialized git repo in %s", project_dir)
+            return True
+        else:
+            logger.warning("Failed to init git repo: %s", result.stderr)
+            return False
+
+    except (subprocess.SubprocessError, FileNotFoundError) as e:
+        logger.warning("Git init error: %s", e)
+        return False
+
+
+def commit_milestone(project_dir: str, milestone: Milestone) -> bool:
+    """Stage all changes and commit with milestone message. Returns success."""
+    try:
+        # git add -A
+        add_result = subprocess.run(
+            ["git", "add", "-A"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            **_SUBPROCESS_ENCODING,
+        )
+        if add_result.returncode != 0:
+            logger.warning("git add failed: %s", add_result.stderr)
+            return False
+
+        # git commit
+        message = f"{GIT_COMMIT_PREFIX}(milestone-{milestone.id}): {milestone.title}"
+        commit_result = subprocess.run(
+            ["git", "commit", "-m", message],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            **_SUBPROCESS_ENCODING,
+        )
+        if commit_result.returncode != 0:
+            # Could be "nothing to commit"
+            if "nothing to commit" in commit_result.stdout:
+                logger.info("Nothing to commit for milestone %s", milestone.id)
+                return True
+            logger.warning("git commit failed: %s", commit_result.stderr)
+            return False
+
+        logger.info("Committed milestone %s: %s", milestone.id, milestone.title)
+        return True
+
+    except (subprocess.SubprocessError, FileNotFoundError) as e:
+        logger.warning("Git commit error: %s", e)
+        return False
+
+
+def push(project_dir: str, remote: str = "origin") -> bool:
+    """Push to remote with retry logic. Returns success."""
+    if not has_remote(project_dir):
+        logger.info("No remote configured, skipping push")
+        return False
+
+    for attempt in range(GIT_PUSH_RETRIES + 1):
+        try:
+            result = subprocess.run(
+                ["git", "push", remote],
+                cwd=project_dir,
+                capture_output=True,
+                text=True,
+                timeout=60,
+                **_SUBPROCESS_ENCODING,
+            )
+            if result.returncode == 0:
+                logger.info("Pushed to %s", remote)
+                return True
+            else:
+                logger.warning(
+                    "Push attempt %d failed: %s", attempt + 1, result.stderr
+                )
+        except (subprocess.SubprocessError, subprocess.TimeoutExpired) as e:
+            logger.warning("Push attempt %d error: %s", attempt + 1, e)
+
+    logger.warning("All push attempts failed")
+    return False
+
+
+def setup_remote(project_dir: str, remote_url: str) -> bool:
+    """Set up or update the origin remote. Returns success."""
+    try:
+        # Check if origin already exists
+        result = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            **_SUBPROCESS_ENCODING,
+        )
+
+        if result.returncode == 0:
+            # Origin exists, update URL
+            set_result = subprocess.run(
+                ["git", "remote", "set-url", "origin", remote_url],
+                cwd=project_dir,
+                capture_output=True,
+                text=True,
+                **_SUBPROCESS_ENCODING,
+            )
+        else:
+            # Origin doesn't exist, add it
+            set_result = subprocess.run(
+                ["git", "remote", "add", "origin", remote_url],
+                cwd=project_dir,
+                capture_output=True,
+                text=True,
+                **_SUBPROCESS_ENCODING,
+            )
+
+        if set_result.returncode == 0:
+            logger.info("Remote origin set to %s", remote_url)
+            return True
+        else:
+            logger.warning("Failed to set remote: %s", set_result.stderr)
+            return False
+
+    except (subprocess.SubprocessError, FileNotFoundError) as e:
+        logger.warning("Git remote setup error: %s", e)
+        return False
+
+
+def has_remote(project_dir: str) -> bool:
+    """Check if a remote is configured."""
+    try:
+        result = subprocess.run(
+            ["git", "remote"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            **_SUBPROCESS_ENCODING,
+        )
+        return result.returncode == 0 and result.stdout.strip() != ""
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return False
+
+
+def final_push(project_dir: str, remote: str = "origin") -> bool:
+    """Commit any remaining changes and push. Returns success."""
+    try:
+        # Stage any remaining changes
+        subprocess.run(
+            ["git", "add", "-A"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            **_SUBPROCESS_ENCODING,
+        )
+
+        # Commit if there are changes
+        commit_result = subprocess.run(
+            ["git", "commit", "-m", "chore: Boris orchestration complete"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            **_SUBPROCESS_ENCODING,
+        )
+        if commit_result.returncode != 0 and "nothing to commit" not in commit_result.stdout:
+            logger.warning("Final commit failed: %s", commit_result.stderr)
+
+        # Push
+        return push(project_dir, remote)
+
+    except (subprocess.SubprocessError, FileNotFoundError) as e:
+        logger.warning("Final push error: %s", e)
+        return False

planner.py

@@ -0,0 +1,161 @@
+
+"""Boris planner - task breakdown via Claude CLI."""
+import json
+import logging
+import os
+import re
+import subprocess
+import sys
+from datetime import datetime
+
+import config
+from state import Milestone, Plan
+
+IS_WINDOWS = sys.platform == "win32"
+
+logger = logging.getLogger(__name__)
+
+
+def create_plan(task: str, project_dir: str) -> Plan:
+    """Break a task into milestones using Claude CLI."""
+    file_listing = _list_project_files(project_dir)
+
+    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"Task: {task}\n"
+        f"Project directory: {project_dir}\n"
+        f"Existing files:\n{file_listing}\n\n"
+        "Return ONLY a JSON array (no other text) of milestones:\n"
+        "[\n"
+        "  {\n"
+        '    "id": "M1",\n'
+        '    "title": "Short title",\n'
+        '    "description": "Detailed description of what to build",\n'
+        '    "depends_on": [],\n'
+        '    "acceptance_criteria": ["criterion 1", "criterion 2"],\n'
+        '    "files_to_create": ["file1.py"],\n'
+        '    "files_to_modify": []\n'
+        "  }\n"
+        "]"
+    )
+
+    try:
+        result = subprocess.run(
+            [config.CLAUDE_CMD, "-p"],
+            input=prompt,
+            capture_output=True,
+            text=True,
+            timeout=300,
+            shell=IS_WINDOWS,
+            encoding="utf-8",
+            errors="replace",
+        )
+
+        if result.returncode != 0:
+            raise RuntimeError(f"Claude CLI failed (exit {result.returncode}): {result.stderr}")
+
+        response = result.stdout.strip()
+
+        # Handle markdown code blocks - strip ```json and ``` if present
+        response = re.sub(r"^```(?:json)?\s*\n?", "", response)
+        response = re.sub(r"\n?```\s*$", "", response)
+        response = response.strip()
+
+        milestones_data = json.loads(response)
+
+        milestones = [
+            Milestone(
+                id=m["id"],
+                title=m["title"],
+                description=m["description"],
+                depends_on=m.get("depends_on", []),
+                acceptance_criteria=m.get("acceptance_criteria", []),
+                files_to_create=m.get("files_to_create", []),
+                files_to_modify=m.get("files_to_modify", []),
+            )
+            for m in milestones_data
+        ]
+
+        plan = Plan(task=task, milestones=milestones)
+
+        # Save plan as markdown
+        plan_path = _save_plan_markdown(plan, task)
+        logger.info("Plan saved to %s", plan_path)
+
+        return plan
+
+    except json.JSONDecodeError as e:
+        raise RuntimeError(f"Failed to parse Claude's plan response as JSON: {e}") from e
+    except subprocess.TimeoutExpired:
+        raise RuntimeError("Claude CLI timed out while generating plan")
+    except FileNotFoundError:
+        raise RuntimeError(
+            f"'{config.CLAUDE_CMD}' command not found. Is Claude CLI installed?"
+        )
+
+
+def _save_plan_markdown(plan: Plan, task: str) -> str:
+    """Save a human-readable markdown version of the plan. Returns filepath."""
+    os.makedirs(config.PLANS_DIR, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"plan_{timestamp}.md"
+    filepath = os.path.join(config.PLANS_DIR, filename)
+
+    lines = [
+        f"# Boris Plan",
+        f"",
+        f"**Task:** {task}",
+        f"**Created:** {plan.created_at}",
+        f"**Milestones:** {len(plan.milestones)}",
+        f"",
+        f"---",
+        f"",
+    ]
+
+    for m in plan.milestones:
+        lines.append(f"## {m.id}: {m.title}")
+        lines.append(f"")
+        lines.append(f"{m.description}")
+        lines.append(f"")
+        if m.depends_on:
+            lines.append(f"**Depends on:** {', '.join(m.depends_on)}")
+            lines.append(f"")
+        lines.append(f"**Acceptance Criteria:**")
+        for c in m.acceptance_criteria:
+            lines.append(f"- {c}")
+        lines.append(f"")
+        if m.files_to_create:
+            lines.append(f"**Files to create:** {', '.join(m.files_to_create)}")
+        if m.files_to_modify:
+            lines.append(f"**Files to modify:** {', '.join(m.files_to_modify)}")
+        lines.append(f"")
+        lines.append(f"---")
+        lines.append(f"")
+
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))
+
+    return filepath
+
+
+def _list_project_files(project_dir: str) -> str:
+    """Walk project_dir and return formatted file listing."""
+    skip_dirs = {".git", "__pycache__", "node_modules", ".boris", ".venv", "venv"}
+    file_list = []
+
+    for root, dirs, files in os.walk(project_dir):
+        # Filter out hidden and skip dirs
+        dirs[:] = [d for d in dirs if d not in skip_dirs and not d.startswith(".")]
+        rel_root = os.path.relpath(root, project_dir)
+        for fname in sorted(files):
+            if rel_root == ".":
+                file_list.append(fname)
+            else:
+                file_list.append(os.path.join(rel_root, fname))
+
+    if not file_list:
+        return "(empty project)"
+
+    return "\n".join(f"  {f}" for f in file_list)