borisxdave 0.3.0__tar.gz → 0.3.1__tar.gz

borisxdave-0.3.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include boris_prompt.md
+include requirements.txt

{borisxdave-0.3.0 → borisxdave-0.3.1}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.1
 Name: borisxdave
-Version: 0.3.0
+Version: 0.3.1
 Summary: Boris - Autonomous Project Orchestrator
 Requires-Python: >=3.8

{borisxdave-0.3.0 → borisxdave-0.3.1}/boris.py

@@ -28,6 +28,123 @@ DEFAULT_MAX_ITERATIONS = 15
 MAX_CORRECTIONS = 2
 MAX_RETRIES = 1
 
+# Swarm mode configuration presets
+SWARM_PRESETS = {
+    "conservative": {
+        "swarm_budget": 3,
+        "swarm_depth": 1,
+        "isolation": "worktree",
+        "no_converge": False,
+    },
+    "balanced": {
+        "swarm_budget": 5,
+        "swarm_depth": 1,
+        "isolation": "worktree",
+        "no_converge": False,
+    },
+    "aggressive": {
+        "swarm_budget": 10,
+        "swarm_depth": 2,
+        "isolation": "worktree",
+        "no_converge": False,
+    },
+    "yolo": {  # Closest to the original emergent behavior
+        "swarm_budget": 999,
+        "swarm_depth": 2,
+        "isolation": "none",
+        "no_converge": True,
+    },
+}
+
+
+class TokenEstimator:
+    """Estimates token usage for Boris orchestration.
+
+    Claude Code runs on a token-based subscription model, not pay-per-API-call.
+    This estimator helps users understand token consumption before committing to
+    a task, and allows setting token budgets to limit usage.
+
+    Token estimates are based on realistic DaveLoop iteration profiles:
+    - Base iteration: ~4000 input tokens (prompt) + ~2000 output tokens (response)
+    - Context growth: each iteration adds ~1500 tokens of accumulated context
+    - Sub-agent spawn: ~3000 tokens each
+    - Convergence run: ~5000 tokens (reads multiple files + analysis)
+    """
+
+    BASE_INPUT_TOKENS = 4000       # Base input tokens per DaveLoop iteration
+    BASE_OUTPUT_TOKENS = 2000      # Base output tokens per DaveLoop iteration
+    CONTEXT_GROWTH_PER_ITER = 1500 # Additional context tokens accumulated per iteration
+    TOKENS_PER_SUB_AGENT = 3000   # Tokens per sub-agent spawn
+    TOKENS_PER_CONVERGENCE = 5000 # Tokens per convergence run
+
+    def __init__(self, max_tokens: int = None):
+        self.max_tokens = max_tokens
+        self.estimated_tokens = 0
+
+    def _tokens_per_iteration(self, iteration_num: int) -> int:
+        """Estimate tokens for a single DaveLoop iteration, accounting for context growth."""
+        input_tokens = self.BASE_INPUT_TOKENS + (iteration_num * self.CONTEXT_GROWTH_PER_ITER)
+        return input_tokens + self.BASE_OUTPUT_TOKENS
+
+    def record_tokens(self, amount: int):
+        """Record estimated token usage."""
+        self.estimated_tokens += amount
+
+    def estimate_batch(self, num_workers: int, avg_iterations: int,
+                       avg_sub_agents: int) -> int:
+        """Estimate tokens for a batch of parallel workers."""
+        worker_tokens = 0
+        for w in range(num_workers):
+            for i in range(avg_iterations):
+                worker_tokens += self._tokens_per_iteration(i)
+        sub_agent_tokens = num_workers * avg_sub_agents * self.TOKENS_PER_SUB_AGENT
+        convergence_tokens = self.TOKENS_PER_CONVERGENCE
+        return worker_tokens + sub_agent_tokens + convergence_tokens
+
+    def estimate_task(self, plan) -> dict:
+        """Estimate total tokens for a Boris plan.
+
+        Returns a dict with breakdown: per-milestone estimates, sub-agent tokens,
+        convergence tokens, and total.
+        """
+        milestones = plan.milestones
+        num_milestones = len(milestones)
+        avg_iterations = 8  # Typical DaveLoop iterations per milestone
+
+        milestone_tokens = 0
+        for i in range(avg_iterations):
+            milestone_tokens += self._tokens_per_iteration(i)
+        total_milestone_tokens = milestone_tokens * num_milestones
+
+        # Estimate convergence runs (one per parallel batch, assume ~ceil(milestones/3) batches)
+        estimated_batches = max(1, (num_milestones + 2) // 3)
+        convergence_tokens = estimated_batches * self.TOKENS_PER_CONVERGENCE
+
+        total = total_milestone_tokens + convergence_tokens
+
+        return {
+            "num_milestones": num_milestones,
+            "avg_iterations_per_milestone": avg_iterations,
+            "tokens_per_milestone": milestone_tokens,
+            "total_milestone_tokens": total_milestone_tokens,
+            "convergence_tokens": convergence_tokens,
+            "total_tokens": total,
+        }
+
+    def check_budget(self, estimated_additional: int) -> bool:
+        """Check if estimated additional tokens fit within budget."""
+        if self.max_tokens is None:
+            return True
+        return (self.estimated_tokens + estimated_additional) <= self.max_tokens
+
+    def summary(self) -> dict:
+        """Return token tracking summary."""
+        return {
+            "estimated_tokens": self.estimated_tokens,
+            "max_tokens": self.max_tokens,
+            "remaining": (self.max_tokens - self.estimated_tokens) if self.max_tokens else None,
+        }
+
 
 def setup_logging() -> logging.Logger:
     """Set up logging to both console and file."""
@@ -82,6 +199,61 @@ def print_plan_summary(plan: state_module.Plan):
     print(flush=True)
 
 
+def prompt_skip_milestones(plan: state_module.Plan, logger: logging.Logger) -> set:
+    """Prompt the user to optionally skip milestones before execution.
+
+    Returns a set of milestone IDs that were marked as skipped.
+    """
+    valid_ids = {m.id for m in plan.milestones}
+
+    try:
+        user_input = input("Enter milestone IDs to skip (comma-separated), or press Enter to run all: ").strip()
+    except EOFError:
+        # Non-interactive environment, skip nothing
+        return set()
+
+    if not user_input:
+        return set()
+
+    # Parse comma-separated milestone IDs
+    requested_ids = {s.strip().upper() for s in user_input.split(",") if s.strip()}
+    skip_ids = requested_ids & valid_ids
+    invalid_ids = requested_ids - valid_ids
+
+    if invalid_ids:
+        print(f"[Boris] WARNING: Unknown milestone IDs ignored: {', '.join(sorted(invalid_ids))}", flush=True)
+        logger.warning("Unknown milestone IDs in skip request: %s", invalid_ids)
+
+    if not skip_ids:
+        return set()
+
+    # Check for dependency warnings: if a skipped milestone is depended on by a non-skipped one
+    skipped_set = skip_ids
+    for m in plan.milestones:
+        if m.id in skipped_set:
+            continue
+        depends_on_skipped = [dep for dep in m.depends_on if dep in skipped_set]
+        if depends_on_skipped:
+            print(
+                f"[Boris] WARNING: {m.id} ({m.title}) depends on skipped milestone(s): "
+                f"{', '.join(depends_on_skipped)}",
+                flush=True,
+            )
+            logger.warning(
+                "Milestone %s depends on skipped milestone(s): %s",
+                m.id, depends_on_skipped,
+            )
+
+    # Mark milestones as skipped
+    for m in plan.milestones:
+        if m.id in skip_ids:
+            m.status = "skipped"
+            print(f"[Boris] Skipping milestone {m.id}: {m.title}", flush=True)
+            logger.info("User skipped milestone %s: %s", m.id, m.title)
+
+    return skip_ids
+
+
 def generate_summary(plan: state_module.Plan, project_dir: str, start_time: datetime) -> str:
     """Generate a summary markdown file and return its path."""
     os.makedirs(PLANS_DIR, exist_ok=True)
@@ -245,6 +417,41 @@ def parse_args() -> argparse.Namespace:
         help="Stop execution after completing this milestone ID (e.g. M4). Implies --incremental."
     )
 
+    # Swarm mode flags
+    parser.add_argument(
+        "--swarm", action="store_true",
+        help="Enable swarm mode: DaveLoops can spawn sub-agents via Task tool"
+    )
+    parser.add_argument(
+        "--swarm-budget", type=int, default=5,
+        help="Max sub-agents per DaveLoop worker in swarm mode (default: 5)"
+    )
+    parser.add_argument(
+        "--swarm-depth", type=int, default=1, choices=[1, 2],
+        help="Max sub-agent depth in swarm mode (default: 1, no recursive spawning)"
+    )
+    parser.add_argument(
+        "--preset", choices=["conservative", "balanced", "aggressive", "yolo"],
+        help="Apply a swarm configuration preset (implies --swarm)"
+    )
+    parser.add_argument(
+        "--isolation", choices=["none", "worktree"], default="none",
+        help="Isolation strategy for parallel workers (default: none)"
+    )
+    parser.add_argument(
+        "--no-converge", action="store_true", dest="no_converge",
+        help="Skip convergence phase after each swarm batch"
+    )
+    parser.add_argument(
+        "--max-tokens", type=int, default=None, dest="max_tokens",
+        help="Maximum estimated token budget for swarm/turbo mode execution (e.g. 500000)"
+    )
+    parser.add_argument(
+        "--estimate", metavar="TASK", nargs="?", const="__FROM_TASK__", dest="estimate",
+        help="Generate plan and print token estimate WITHOUT executing. "
+             "Use alone (boris --estimate 'task') or with positional task."
+    )
+
     return parser.parse_args()
 
 
@@ -516,16 +723,177 @@ def _process_milestone_verdict(verdict_result, result, milestone, plan, st, proj
             state_module.save(st)
 
 
+def validate_turbo_batch(ready: list, plan: state_module.Plan, logger: logging.Logger) -> list:
+    """Filter out milestones from a turbo batch whose dependencies were skipped.
+
+    These milestones cannot succeed without their dependency's output.
+    Also enforces foundation-first: first batch only runs milestones with no dependencies.
+    """
+    skipped_ids = {m.id for m in plan.milestones if m.status == "skipped"}
+    valid = []
+    for m in ready:
+        skipped_deps = [d for d in m.depends_on if d in skipped_ids]
+        if skipped_deps:
+            logger.warning(
+                "Milestone %s depends on skipped milestone(s) %s - deferring from turbo batch",
+                m.id, skipped_deps
+            )
+            print(f"[Boris] WARNING: {m.id} skipped from turbo batch - depends on skipped: {skipped_deps}", flush=True)
+        else:
+            valid.append(m)
+    return valid
+
+
+def _run_convergence(st, plan, project_dir, batch_milestones, logger):
+    """Run a convergence agent after a parallel batch to resolve conflicts."""
+    completed_in_batch = [m for m in batch_milestones if m.status == "completed"]
+    if len(completed_in_batch) < 2:
+        return  # No conflicts possible with 0-1 completed milestones
+
+    # Collect all files touched by this batch and check for overlaps
+    file_owners = {}
+    conflicts = []
+    for m in completed_in_batch:
+        for f in (m.files_to_create or []) + (m.files_to_modify or []):
+            if f in file_owners:
+                conflicts.append((f, file_owners[f], m.id))
+            file_owners[f] = m.id
+
+    if not conflicts:
+        logger.info("Convergence: No file conflicts detected in batch")
+        print("[Boris] Convergence: No conflicts detected. Skipping.", flush=True)
+        return
+
+    print(f"[Boris] Convergence: {len(conflicts)} potential conflict(s) detected", flush=True)
+    for filepath, owner1, owner2 in conflicts:
+        print(f"  [Boris]   {filepath}: written by {owner1} and {owner2}", flush=True)
+
+    # Build convergence prompt
+    conflict_text = "\n".join(
+        f"- {f}: modified by {o1} and {o2}" for f, o1, o2 in conflicts
+    )
+
+    convergence_prompt = f"""# Convergence Task
+
+Multiple parallel agents modified overlapping files. Resolve any conflicts.
+
+## Conflicts Detected
+{conflict_text}
+
+## Milestones Completed in This Batch
+{chr(10).join(f'- {m.id}: {m.title}' for m in completed_in_batch)}
+
+## Instructions
+1. Read each conflicted file
+2. Check for type mismatches, duplicate definitions, incompatible interfaces
+3. Reconcile into a consistent state
+4. Run `tsc --noEmit` (TypeScript) or equivalent type checker
+5. Fix any remaining build errors
+6. Do NOT add new features - only resolve conflicts between existing code
+
+When all conflicts are resolved and the build is clean, output [DAVELOOP:RESOLVED].
+"""
+
+    # Run convergence via DaveLoop (without Task tool - no swarm for convergence)
+    result = engine.run(convergence_prompt, project_dir, max_iterations=5)
+    if result.resolved:
+        print("[Boris] Convergence: All conflicts resolved", flush=True)
+        logger.info("Convergence phase completed successfully")
+    else:
+        print("[Boris] WARNING: Convergence could not resolve all conflicts", flush=True)
+        logger.warning("Convergence phase did not fully resolve")
+
+
+def _print_swarm_dashboard(project_dir: str, batch_num: int, batch_milestones: list):
+    """Print a swarm status dashboard showing all active workers in the current batch (B7)."""
+    statuses = engine.read_worker_statuses(project_dir)
+    if not statuses:
+        return
+
+    active = sum(1 for s in statuses.values() if s.get("state") in ("starting", "working"))
+    total_actions = sum(s.get("actions", 0) for s in statuses.values())
+
+    print(flush=True)
+    print("=== BORIS SWARM STATUS ===", flush=True)
+    print(f"Batch {batch_num} | Workers: {active} active / {len(statuses)} total | Actions: {total_actions}", flush=True)
+    print(flush=True)
+
+    for m in batch_milestones:
+        status = statuses.get(m.id, {})
+        state = status.get("state", "unknown")
+        actions = status.get("actions", 0)
+        reasoning = status.get("reasoning_blocks", 0)
+        interrupts = status.get("interrupts", 0)
+        last = status.get("last_action", "")
+
+        # Progress indicator based on reasoning blocks (rough proxy)
+        bar_len = min(reasoning, 10)
+        bar = "#" * bar_len + "-" * (10 - bar_len)
+
+        state_str = state.upper()
+        interrupt_str = f" | {interrupts} interrupts" if interrupts > 0 else ""
+        print(f"[{m.id}] {m.title[:30]:<30} [{bar}] {state_str} | {actions} actions{interrupt_str}", flush=True)
+        if last:
+            print(f"      Last: {last}", flush=True)
+
+    # Show file locks if file_lock.py is available
+    try:
+        from file_lock import FileLockManager
+        flm = FileLockManager(project_dir)
+        locks = flm.get_locked_files()
+        if locks:
+            lock_strs = [f"{os.path.basename(f)} ({owner})" for f, owner in locks.items()]
+            print(f"\nFile locks: {', '.join(lock_strs)}", flush=True)
+    except ImportError:
+        pass
+
+    print("===========================", flush=True)
+    print(flush=True)
+
+
+def _apply_preset(args):
+    """Apply a swarm preset to args if specified. Preset implies --swarm."""
+    if not args.preset:
+        return
+    args.swarm = True
+    preset = SWARM_PRESETS[args.preset]
+    # Only override if user didn't explicitly set these
+    if args.swarm_budget == 5:  # default value
+        args.swarm_budget = preset["swarm_budget"]
+    if args.swarm_depth == 1:  # default value
+        args.swarm_depth = preset["swarm_depth"]
+    if args.isolation == "none":  # default value
+        args.isolation = preset.get("isolation", "none")
+    if not args.no_converge:
+        args.no_converge = preset["no_converge"]
+
+
 def main():
     """Main Boris orchestration loop."""
     args = parse_args()
 
+    # Apply swarm preset if specified (implies --swarm)
+    _apply_preset(args)
+
     # --stop-at implies incremental mode
     if args.stop_at:
         args.incremental = True
 
+    # Handle --estimate: resolve the task description from either the flag or positional arg
+    if args.estimate is not None:
+        estimate_task = args.estimate if args.estimate != "__FROM_TASK__" else args.task
+        if not estimate_task:
+            print("[Boris] Error: --estimate requires a task description", flush=True)
+            sys.exit(1)
+        args.task = estimate_task
+
     logger = setup_logging()
 
+    # Initialize token estimator for swarm/turbo mode
+    token_estimator = None
+    if getattr(args, 'swarm', False) or getattr(args, 'max_tokens', None) or getattr(args, 'turbo', False):
+        token_estimator = TokenEstimator(max_tokens=args.max_tokens)
+
     # Create required dirs
     os.makedirs(PLANS_DIR, exist_ok=True)
     os.makedirs(LOGS_DIR, exist_ok=True)
@@ -567,6 +935,9 @@ def main():
 
         print_plan_summary(plan)
 
+        # Prompt user to skip milestones before execution
+        prompt_skip_milestones(plan, logger)
+
         # Create initial state from the loaded plan
         st = state_module.State(
             plan=plan,
@@ -625,10 +996,32 @@ def main():
 
         print_plan_summary(plan)
 
+        # --estimate mode: print token estimate and exit without executing
+        if args.estimate is not None:
+            estimator = TokenEstimator()
+            estimate = estimator.estimate_task(plan)
+            print("=" * 60, flush=True)
+            print("  BORIS - Token Estimate", flush=True)
+            print("=" * 60, flush=True)
+            print(f"  Milestones:          {estimate['num_milestones']}", flush=True)
+            print(f"  Avg iterations each: {estimate['avg_iterations_per_milestone']}", flush=True)
+            print(f"  Tokens/milestone:    {estimate['tokens_per_milestone']:,}", flush=True)
+            print(f"  Milestone tokens:    {estimate['total_milestone_tokens']:,}", flush=True)
+            print(f"  Convergence tokens:  {estimate['convergence_tokens']:,}", flush=True)
+            print(f"  ----------------------------------------", flush=True)
+            print(f"  TOTAL ESTIMATED:     {estimate['total_tokens']:,} tokens", flush=True)
+            print("=" * 60, flush=True)
+            print(flush=True)
+            print("[Boris] Estimate-only mode. No execution performed.", flush=True)
+            return
+
         if args.plan_only:
             print("[Boris] Plan-only mode. Exiting.", flush=True)
             return
 
+        # Prompt user to skip milestones before execution
+        prompt_skip_milestones(plan, logger)
+
         # Create initial state
         st = state_module.State(
             plan=plan,
@@ -686,6 +1079,27 @@ def main():
                             state_module.save(st)
                         break
 
+                    # Dependency-aware batch validation: filter milestones with skipped deps
+                    ready = validate_turbo_batch(ready, plan, logger)
+                    if not ready:
+                        logger.warning("All ready milestones filtered out by turbo batch validation")
+                        break
+
+                    # Foundation-first: first batch only runs milestones with no dependencies
+                    if batch_num == 0:
+                        foundation = [m for m in ready if not m.depends_on]
+                        if foundation:
+                            ready = foundation[:1]  # Only one foundation milestone at a time
+
+                    # Token budget check (swarm/turbo mode)
+                    if token_estimator:
+                        estimated = token_estimator.estimate_batch(len(ready), args.max_iter, args.swarm_budget if getattr(args, 'swarm', False) else 0)
+                        if not token_estimator.check_budget(estimated):
+                            print(f"[Boris] Token budget exceeded. Estimated: {token_estimator.estimated_tokens + estimated:,}, Budget: {token_estimator.max_tokens:,} tokens", flush=True)
+                            logger.warning("Token budget exceeded, stopping execution")
+                            break
+                        token_estimator.record_tokens(estimated)
+
                     batch_num += 1
                     batch_ids = [m.id for m in ready]
                     print(flush=True)
@@ -711,7 +1125,12 @@ def main():
                         prompt_map[m.id] = prompt
 
                     # Run all DaveLoops in parallel
-                    parallel_results = engine.run_parallel(tasks, project_dir, args.max_iter)
+                    isolation = getattr(args, 'isolation', 'none') if getattr(args, 'swarm', False) else 'none'
+                    parallel_results = engine.run_parallel(tasks, project_dir, args.max_iter, isolation=isolation)
+
+                    # Print swarm dashboard after parallel run completes (B7)
+                    _print_swarm_dashboard(project_dir, batch_num, ready)
+                    engine.clear_worker_statuses(project_dir)
 
                     # Process verdicts sequentially (corrections/retries run sequentially)
                     batch_summary = {}
@@ -731,6 +1150,13 @@ def main():
                         )
                         batch_summary[milestone.id] = milestone.status.upper()
 
+                    # Convergence phase: reconcile type conflicts from parallel workers
+                    if not getattr(args, 'no_converge', False):
+                        completed_in_batch = [m for m, r in parallel_results if m.status == "completed"]
+                        if len(completed_in_batch) > 1:
+                            print(f"[Boris] TURBO: Running convergence phase for batch {batch_num}...", flush=True)
+                            _run_convergence(st, plan, project_dir, completed_in_batch, logger)
+
                     # Git commits sequentially after entire batch
                     if not st.no_git:
                         for milestone, result in parallel_results: