misterdev 0.2.0__py3-none-any.whl

misterdev/core/planning/sovereign.py

@@ -0,0 +1,308 @@
+"""Sovereign-tier orchestration capabilities.
+
+Inspired by June 2026 arXiv research:
+- Agentic Engineering: Code as transient resource (arXiv:2606.05608)
+- Long-Horizon Reasoning: AB-MCTS (Sakana AI / Marlin, June 2026)
+- Discordance-Aware Reasoning (CyberDrift, arXiv:2606.15101)
+"""
+
+import json
+import shutil
+import subprocess
+import sys
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+from misterdev.logging_setup import setup_logger
+from misterdev.llm.client import BaseLLMClient
+from misterdev.llm.responses import extract_json_array
+from misterdev.utils.file_utils import safe_ref_slug
+
+logger = setup_logger(__name__)
+
+
+class EphemeralCodeManager:
+    """Manages code as a transient, instrumental resource.
+
+    In 'Agentic Engineering', code is often generated just to solve a specific
+    reasoning step and can be discarded once its goal is achieved.
+    """
+
+    def __init__(self, project_path: Path):
+        self.session_id = uuid.uuid4().hex[:8]
+        self.ephemeral_dir = (
+            project_path / ".orchestrator" / "ephemeral" / self.session_id
+        )
+        self.ephemeral_dir.mkdir(parents=True, exist_ok=True)
+
+    def run_ephemeral_script(self, code: str, name: str = "temp") -> Tuple[bool, str]:
+        """Executes a transient script and returns its output."""
+        # Sanitize the (LLM-supplied) name: a '/' or other path char would turn
+        # the filename into a non-existent subdir and raise on write, crashing
+        # the whole build from this best-effort probe step.
+        safe = safe_ref_slug(name, fallback="temp")
+        script_path = self.ephemeral_dir / f"{safe}_{uuid.uuid4().hex[:4]}.py"
+        logger.info(f"Executing ephemeral logic: {script_path.name}")
+        try:
+            self.ephemeral_dir.mkdir(parents=True, exist_ok=True)
+            script_path.write_text(code, encoding="utf-8")
+            res = subprocess.run(
+                [sys.executable, str(script_path)],
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            output = res.stdout
+            if res.stderr:
+                output += f"\nERR: {res.stderr}"
+            return res.returncode == 0, output
+        except subprocess.TimeoutExpired:
+            return False, "Ephemeral script timed out after 60s"
+        except Exception as e:
+            return False, str(e)
+
+    def cleanup(self):
+        """Discards all transient resources from this session."""
+        if self.ephemeral_dir.exists():
+            shutil.rmtree(self.ephemeral_dir, ignore_errors=True)
+            logger.info(f"Cleaned up ephemeral session {self.session_id}")
+
+    def __enter__(self) -> "EphemeralCodeManager":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
+        self.cleanup()
+        return False
+
+
+class ABMCTSPlanner:
+    """Adaptive Branching Monte Carlo Tree Search for task planning.
+
+    Explores multiple reasoning branches to find the optimal execution path.
+    Skips branching for trivial/small tasks to save LLM calls.
+    """
+
+    def __init__(self, llm_client: BaseLLMClient):
+        self.llm = llm_client
+
+    def branch_and_evaluate(self, task: str, context: str, branches: int = 3) -> str:
+        """Simulates multiple implementation paths and selects the winner.
+
+        Returns the original task unchanged if branching is not worthwhile.
+        """
+        # Skip branching for short specs (trivial work)
+        if len(task.split()) < 50:
+            logger.info("AB-MCTS: Skipping branching (spec too short to benefit)")
+            return task
+
+        logger.info(f"AB-MCTS: Branching (n={branches})...")
+
+        simulations = []
+        for i in range(branches):
+            prompt = (
+                f"Simulation Path {i + 1}: Propose a unique implementation strategy "
+                f"for this task.\nContext: {context}\nTask: {task}"
+            )
+            strategy = self.llm.generate_code(
+                prompt, "You are a competitive systems architect."
+            )
+            simulations.append(strategy)
+
+        # Self-Evaluation / Discordance-Aware Selection
+        numbered = "\n".join(
+            f"--- PATH {i + 1} ---\n{s}" for i, s in enumerate(simulations)
+        )
+        eval_prompt = (
+            f"Evaluate these {branches} competing implementation strategies.\n"
+            f"Select the one with the highest 'Verifiability' and lowest 'Regression Risk'.\n\n"
+            f"Strategies:\n{numbered}\n\n"
+            f"Return ONLY the content of the selected strategy."
+        )
+        logger.info("AB-MCTS: Evaluating branches...")
+        return self.llm.generate_code(
+            eval_prompt, "You are a discordance-aware evaluator."
+        )
+
+
+class ProbeGenerator:
+    """Synthesizes empirical fact-finding probes with high-rigor reflection.
+
+    Identifies 'assumptions' in the spec and generates scripts to verify them
+    using Python's 'inspect', 'ast', and 'dir' modules for reflective analysis.
+    """
+
+    def __init__(self, llm_client: BaseLLMClient):
+        self.llm = llm_client
+
+    def generate_probes(
+        self, spec: str, assessment_summary: str
+    ) -> List[Dict[str, str]]:
+        """Analyzes spec and generates a list of {name, purpose, script} probes."""
+        prompt = f"""Analyze this technical spec and project assessment.
+Identify 1-3 critical 'assumptions' or 'unknowns' about the live codebase or environment.
+
+Spec: {spec}
+Assessment: {assessment_summary}
+
+For each unknown, synthesize a transient Python 'Probe' script that uses REFLECTIVE techniques:
+- Use 'inspect.signature()' to verify function/method arguments.
+- Use 'inspect.getsource()' to see the actual logic.
+- Use 'dir()' and 'getattr()' to probe runtime objects.
+- Use 'ast.parse()' on local files to check structural definitions.
+
+The script MUST print its findings clearly to stdout.
+
+Return a JSON array: [{{"name": "...", "purpose": "...", "script": "..."}}]
+Return ONLY the JSON array.
+"""
+        logger.info("Generating empirical probes...")
+        try:
+            response = self.llm.generate_code(
+                prompt, "You are a senior empirical researcher."
+            )
+            return extract_json_array(response)
+        except Exception as e:
+            logger.error(f"Failed to generate probes: {e}")
+
+        return []
+
+
+class ToolSynthesizer:
+    """Synthesizes project-local helper tools on-the-fly."""
+
+    def __init__(self, project_path: Path):
+        self.tools_dir = project_path / ".orchestrator" / "synthesized_tools"
+        self.tools_dir.mkdir(parents=True, exist_ok=True)
+
+    def synthesize_tool(
+        self, name: str, purpose: str, llm_client: BaseLLMClient
+    ) -> str:
+        """Asks LLM to generate a Python script for a specific purpose."""
+        prompt = (
+            f"Synthesize a standalone Python script to serve as a local tool.\n"
+            f"Purpose: {purpose}\nTool Name: {name}\n\n"
+            f"Requirements:\n"
+            f"- Single file, standard library or project-available dependencies.\n"
+            f"- Executable as 'python tool.py'.\n"
+            f"- Return ONLY the code in a ```python code block."
+        )
+        logger.info(f"Synthesizing tool: {name}")
+        response = llm_client.generate_code(prompt, "You are a senior tools engineer.")
+
+        code = _extract_code_block(response)
+        tool_path = self.tools_dir / f"{safe_ref_slug(name, fallback='tool')}.py"
+        tool_path.write_text(code, encoding="utf-8")
+        logger.info(f"Tool {name} saved to {tool_path}")
+        return str(tool_path)
+
+
+class StrategyOptimizer:
+    """Optimizes agentic workflows via strategy simulation.
+
+    Caches strategy per task category to avoid redundant LLM calls.
+    """
+
+    STRATEGIES = {
+        "surgical": "Search-then-Edit (Fast, minimal context)",
+        "iterative": "Standard Try-Test-Fix Loop (Thorough)",
+        "architectural": "Spec-first Redesign (High impact)",
+        "agentic": "Sovereign Agentic Engineering (Transient code, multi-agent)",
+    }
+
+    def __init__(self):
+        self._cache: Dict[str, str] = {}
+
+    def select_best_strategy(
+        self,
+        task_description: str,
+        task_category: str,
+        project_summary: str,
+        llm_client: BaseLLMClient,
+    ) -> str:
+        """Select strategy, using cache for repeated categories."""
+        if task_category in self._cache:
+            cached = self._cache[task_category]
+            logger.info(f"Strategy (cached for {task_category}): {cached.upper()}")
+            return cached
+
+        strategy_list = "\n".join(
+            f"{i + 1}. {k}: {v}" for i, (k, v) in enumerate(self.STRATEGIES.items())
+        )
+        prompt = (
+            f"Select the most efficient execution strategy.\n\n"
+            f"Project: {project_summary}\n"
+            f"Task category: {task_category}\n"
+            f"Task: {task_description}\n\n"
+            f"Available Strategies:\n{strategy_list}\n\n"
+            f"Return ONLY the key (surgical, iterative, architectural, or agentic)."
+        )
+        best = (
+            llm_client.generate_code(prompt, "You are a workflow optimizer.")
+            .strip()
+            .lower()
+        )
+        if best not in self.STRATEGIES:
+            best = "iterative"
+
+        self._cache[task_category] = best
+        logger.info(f"Strategy selected for {task_category}: {best.upper()}")
+        return best
+
+
+class RealTimeAligner:
+    """Ensures multi-step alignment via a 'Shared Certified Repository' pattern."""
+
+    def __init__(self, project_path: Path):
+        self.cert_file = project_path / ".orchestrator" / "consensus.json"
+        self.cert_file.parent.mkdir(parents=True, exist_ok=True)
+        self._load()
+
+    def _load(self):
+        if self.cert_file.exists():
+            try:
+                self.data = json.loads(self.cert_file.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                self.data = {"invariants": [], "decisions": []}
+        else:
+            self.data = {"invariants": [], "decisions": []}
+
+    def certify_decision(self, decision: str, rationale: str):
+        """Records a certified project decision to keep future tasks aligned."""
+        self.data["decisions"].append(
+            {
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "decision": decision,
+                "rationale": rationale,
+            }
+        )
+        self.cert_file.write_text(json.dumps(self.data, indent=2), encoding="utf-8")
+        logger.info(f"Certified Decision: {decision}")
+
+    def get_consensus_context(self) -> str:
+        """Returns the current project consensus as a prompt string."""
+        if not self.data["decisions"]:
+            return "No prior decisions recorded."
+
+        lines = ["## Project Consensus (Certified)"]
+        for d in self.data["decisions"]:
+            lines.append(f"- {d['decision']} (Rationale: {d['rationale']})")
+        return "\n".join(lines)
+
+
+def _extract_code_block(response: str) -> str:
+    """Extract the first code block from an LLM response."""
+    lines = response.split("\n")
+    in_block = False
+    code_lines = []
+    for line in lines:
+        if line.strip().startswith("```") and not in_block:
+            in_block = True
+            # Skip the opening fence line
+            continue
+        if line.strip().startswith("```") and in_block:
+            break
+        if in_block:
+            code_lines.append(line)
+    return "\n".join(code_lines) if code_lines else response.strip()

misterdev/core/planning/targets.py

@@ -0,0 +1,201 @@
+"""Multi-target (polyglot) gate routing.
+
+A monorepo can hold several sub-projects in different languages — e.g. a Rust
+core plus a TypeScript web client and a Swift app — each with its OWN build/test/
+lint toolchain. The orchestrator otherwise assumes ONE gate for the whole repo,
+so a task editing the web client would be (mis)gated with the Rust commands.
+
+A ``targets`` list in project.yaml declares those sub-projects::
+
+    targets:
+      - name: core
+        path: emathy-core
+        build_command: "cargo build -p emathy-core"
+        test_command: "cargo test -p emathy-core --lib"
+      - name: web
+        path: clients/web
+        build_command: "npm run typecheck"
+
+For each task, :func:`select_target` picks the target that owns the task's files,
+and the executor gates that task with THAT target's commands. With no ``targets``
+declared (or no match), everything falls back to the top-level commands, so the
+single-target path is byte-identical to before.
+"""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Directories that never contain a sub-project worth gating (vendored deps, build
+# output, VCS), so discovery skips them.
+_SKIP_DIRS = {
+    "node_modules",
+    "target",
+    "dist",
+    "build",
+    "pkg",
+    "vendor",
+    "Pods",
+    ".git",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".next",
+    ".gradle",
+    ".cargo",
+}
+
+# A directory holding any of these is the root of a sub-project (one toolchain).
+_BUILD_MARKERS = (
+    "Cargo.toml",
+    "package.json",
+    "Package.swift",
+    "go.mod",
+    "meson.build",
+    "build.gradle",
+    "build.gradle.kts",
+    "pyproject.toml",
+    "CMakeLists.txt",
+)
+
+
+def _has_marker(d: Path) -> bool:
+    if any((d / m).exists() for m in _BUILD_MARKERS):
+        return True
+    return any(d.glob("*.csproj")) or any(d.glob("*.sln"))
+
+
+def _plugin_target_for(d: Path):
+    """First registered target plugin whose markers match ``d``, or None.
+
+    A target plugin is any object exposing ``markers`` (filenames or globs) and
+    ``commands(dir) -> dict`` (build/test/lint/typecheck keys), so a third party
+    can add a language/build system the built-in markers don't cover. See
+    ``misterdev.plugins.TARGETS``.
+    """
+    from misterdev.plugins import TARGETS
+
+    for name in TARGETS.names():
+        target = TARGETS.get(name)
+        for marker in getattr(target, "markers", ()):
+            if any(ch in marker for ch in "*?[") and any(d.glob(marker)):
+                return target
+            if (d / marker).exists():
+                return target
+    return None
+
+
+def discover_targets(project_path: str, max_depth: int = 3) -> List[Dict[str, Any]]:
+    """Auto-detect sub-projects (targets) in a polyglot monorepo.
+
+    Walks the tree and records the SHALLOWEST build marker in each subtree (a
+    Cargo workspace at ``rust/`` is one target, not one per crate — discovery does
+    not descend past a found marker). The repo root itself is never a target (it
+    is the top-level fallback). Build/test commands are detected per sub-project.
+
+    Conservative on purpose: returns [] unless at least TWO distinct sub-projects
+    are found, so a normal single-project repo is never turned into "targets" and
+    behavior is unchanged. Commands are best-effort — explicit ``targets`` in
+    project.yaml override and tune them.
+    """
+    from misterdev.analyzers.project_analyzer import (
+        detect_build_command,
+        detect_test_command,
+    )
+
+    root = Path(project_path)
+    targets: List[Dict[str, Any]] = []
+
+    def scan(d: Path, depth: int, rel: str) -> None:
+        if depth > max_depth:
+            return
+        if d.name in _SKIP_DIRS or (rel and d.name.startswith(".")):
+            return
+        plugin = _plugin_target_for(d) if rel else None
+        if rel and (_has_marker(d) or plugin is not None):
+            if plugin is not None:
+                cmds = plugin.commands(d) or {}
+                build = cmds.get("build_command")
+                test = cmds.get("test_command")
+            else:
+                cmds = {}
+                build = detect_build_command(d)
+                test = detect_test_command(d)
+            if build or test:
+                target = {
+                    "name": rel.replace("/", "-"),
+                    "path": rel,
+                    "build_command": build,
+                    "test_command": test,
+                }
+                for extra in ("lint_command", "typecheck_command"):
+                    if cmds.get(extra):
+                        target[extra] = cmds[extra]
+                targets.append(target)
+            return  # do not descend into a found sub-project
+        try:
+            children = sorted(c for c in d.iterdir() if c.is_dir())
+        except OSError:
+            return
+        for child in children:
+            scan(child, depth + 1, f"{rel}/{child.name}" if rel else child.name)
+
+    scan(root, 0, "")
+    return targets if len(targets) >= 2 else []
+
+
+def _norm(path: str) -> str:
+    return (path or "").strip().strip("/")
+
+
+def _owns(target_path: str, file_path: str) -> bool:
+    """True when ``file_path`` lives under ``target_path`` (or equals it)."""
+    tp = _norm(target_path)
+    fp = _norm(file_path)
+    if not tp:
+        return False
+    return fp == tp or fp.startswith(tp + "/")
+
+
+def select_target(
+    targets: List[Dict[str, Any]], file_paths: List[str]
+) -> Optional[Dict[str, Any]]:
+    """Pick the declared target that owns the most of ``file_paths``, or None.
+
+    Ties break toward the more specific (longer) target path, so a nested target
+    (``clients/web/sub``) wins over its parent. Returns None when there are no
+    targets, no files, or no target owns any file — the caller then uses the
+    top-level commands.
+    """
+    if not targets or not file_paths:
+        return None
+    best: Optional[Dict[str, Any]] = None
+    best_count = 0
+    best_len = -1
+    for t in targets:
+        tp = _norm(t.get("path", ""))
+        if not tp:
+            continue
+        count = sum(1 for f in file_paths if _owns(tp, f))
+        if count == 0:
+            continue
+        if count > best_count or (count == best_count and len(tp) > best_len):
+            best, best_count, best_len = t, count, len(tp)
+    return best
+
+
+_GATE_KEYS = ("build_command", "test_command", "lint_command", "typecheck_command")
+
+
+def target_commands(
+    target: Optional[Dict[str, Any]], config: Dict[str, Any]
+) -> Dict[str, Optional[str]]:
+    """Resolve the effective build/test/lint/typecheck commands for a task.
+
+    A MATCHED target is self-contained: only the commands it declares apply, and
+    any it omits are skipped (None) — NOT inherited from the top-level, which is
+    usually a different toolchain (inheriting ``cargo test`` onto a web task would
+    be meaningless). With NO matched target, the top-level commands are used
+    unchanged (the single-target path).
+    """
+    source = target if target is not None else config
+    return {key: source.get(key) for key in _GATE_KEYS}