pulse-coding-agent 0.1.0__py3-none-any.whl

pulse/patch.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from pulse.context import ContextManager
+from pulse.edits import ApprovalHandler, EditWorkflow
+from pulse.mutations import MutationTracker
+from pulse.reasoning import ReasoningEngine
+from pulse.safety.safety_manager import SafetyManager
+from pulse.task_manager import TaskManager
+
+
+class PatchEngine:
+    def __init__(
+        self,
+        edits: EditWorkflow,
+        safety_manager: SafetyManager,
+        mutations: MutationTracker,
+        context_manager: ContextManager,
+        reasoning_engine: ReasoningEngine,
+        task_manager: TaskManager,
+    ) -> None:
+        self.edits = edits
+        self.safety_manager = safety_manager
+        self.mutations = mutations
+        self.context_manager = context_manager
+        self.reasoning_engine = reasoning_engine
+        self.task_manager = task_manager
+
+    def locate_node(self, file_path: str | Path, target_name: str) -> tuple[int, int] | None:
+        """Find the start and end line numbers of a target function or class."""
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+        
+        content = path.read_text(encoding="utf-8")
+        try:
+            tree = ast.parse(content)
+        except SyntaxError as e:
+            raise ValueError(f"Cannot parse {file_path}: syntax error: {e}")
+
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):  # noqa: SIM102
+                if node.name == target_name:
+                    return (node.lineno, node.end_lineno)
+        return None
+
+    async def apply_patch(
+        self,
+        file_path: str,
+        target_name: str,
+        operation: str,
+        content: str | None,
+        approve: ApprovalHandler,
+    ) -> bool:
+        """Apply a patch operation to a target function or class."""
+        path = Path(file_path)
+        
+        # 1. Authorize via SafetyManager
+        is_safe = await self.safety_manager.authorize(
+            action="patch", target=file_path, detail=f"Patch {target_name} ({operation})"
+        )
+        if not is_safe:
+            return False
+
+        # 2. Locate AST node
+        loc = self.locate_node(path, target_name)
+        if not loc:
+            raise ValueError(f"Target '{target_name}' not found in {file_path}")
+        start_line, end_line = loc
+
+        # 3. Generate modified content
+        original_content = path.read_text(encoding="utf-8")
+        lines = original_content.splitlines(keepends=True)
+        
+        # Calculate indent of the target line
+        target_line_str = lines[start_line - 1]
+        indent = len(target_line_str) - len(target_line_str.lstrip())
+        indent_str = target_line_str[:indent]
+
+        # Prepare payload
+        payload_lines = []
+        if content:
+            for line in content.splitlines(keepends=True):
+                payload_lines.append(indent_str + line if line.strip() else line)
+        
+        if operation == "replace":
+            new_lines = lines[:start_line - 1] + payload_lines + lines[end_line:]
+        elif operation == "insert":
+            # Insert before the node
+            new_lines = lines[:start_line - 1] + payload_lines + lines[start_line - 1:]
+        elif operation == "delete":
+            new_lines = lines[:start_line - 1] + lines[end_line:]
+        elif operation == "rename":
+            if not content:
+                raise ValueError("Rename operation requires new name in content")
+            new_name = content.strip()
+            # Simple replace first line definition
+            first_line = lines[start_line - 1]
+            first_line = first_line.replace(f"def {target_name}", f"def {new_name}")
+            first_line = first_line.replace(f"class {target_name}", f"class {new_name}")
+            new_lines = lines[:start_line - 1] + [first_line] + lines[start_line:]
+        else:
+            raise ValueError(f"Unknown patch operation: {operation}")
+
+        modified_content = "".join(new_lines)
+
+        # 4. Validate syntax
+        try:
+            ast.parse(modified_content)
+        except SyntaxError as e:
+            # Syntax validation failed
+            raise ValueError(f"Patch would result in invalid Python syntax: {e}")
+
+        # 5. Apply via EditWorkflow
+        with self.mutations.transaction(command="pulse patch"):
+            result = await self.edits.request_and_apply(
+                file_path=file_path,
+                content=modified_content,
+                reason=f"Patch Engine: {operation} {target_name}",
+                approve=approve
+            )
+            
+            if not result.applied:
+                # Need rollback if failed? Not applied means we didn't touch FS yet, just rejected.
+                return False
+                
+        return True

pulse/planner/__init__.py

@@ -0,0 +1,3 @@
+from pulse.planner.execution_loop import AutonomousLoop, LoopResult, LoopStepState
+
+__all__ = ["AutonomousLoop", "LoopResult", "LoopStepState"]

pulse/planner/dag_planner.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class DAGTaskNode:
+    id: str
+    description: str
+    target_files: list[str] = field(default_factory=list)
+    inputs: list[str] = field(default_factory=list)
+    outputs: list[str] = field(default_factory=list)
+    dependencies: set[str] = field(default_factory=set)
+
+
+class DAGPlanner:
+    """Decomposes multi-file features into a Directed Acyclic Graph of execution steps."""
+
+    def __init__(self) -> None:
+        self.nodes: dict[str, DAGTaskNode] = {}
+
+    def add_task(
+        self,
+        task_id: str,
+        description: str,
+        target_files: list[str] | None = None,
+        inputs: list[str] | None = None,
+        outputs: list[str] | None = None,
+        dependencies: set[str] | None = None,
+    ) -> DAGTaskNode:
+        if task_id in self.nodes:
+            raise ValueError(f"Task node already exists: {task_id}")
+        node = DAGTaskNode(
+            id=task_id,
+            description=description,
+            target_files=target_files or [],
+            inputs=inputs or [],
+            outputs=outputs or [],
+            dependencies=set(dependencies or []),
+        )
+        self.nodes[task_id] = node
+        return node
+
+    def add_dependency(self, task_id: str, depends_on_id: str) -> None:
+        if task_id not in self.nodes or depends_on_id not in self.nodes:
+            raise KeyError("Both task_id and depends_on_id must exist in DAG.")
+        if task_id == depends_on_id:
+            raise ValueError("A task cannot depend on itself.")
+        self.nodes[task_id].dependencies.add(depends_on_id)
+        if self._has_cycle():
+            self.nodes[task_id].dependencies.remove(depends_on_id)
+            raise ValueError("Adding this dependency creates a cycle in the DAG.")
+
+    def get_execution_order(self) -> list[DAGTaskNode]:
+        """Returns topological sort order of tasks for execution."""
+        in_degree: dict[str, int] = {node_id: 0 for node_id in self.nodes}
+        graph: dict[str, list[str]] = {node_id: [] for node_id in self.nodes}
+
+        for node_id, node in self.nodes.items():
+            for dep in node.dependencies:
+                graph[dep].append(node_id)
+                in_degree[node_id] += 1
+
+        queue = [node_id for node_id, count in in_degree.items() if count == 0]
+        order: list[DAGTaskNode] = []
+
+        while queue:
+            current_id = queue.pop(0)
+            order.append(self.nodes[current_id])
+            for neighbor in graph[current_id]:
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        if len(order) != len(self.nodes):
+            raise ValueError("Cycle detected in DAG planner tasks.")
+
+        return order
+
+    def _has_cycle(self) -> bool:
+        try:
+            self.get_execution_order()
+            return False
+        except ValueError:
+            return True

pulse/planner/execution_loop.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+from pulse.context import ContextManager
+from pulse.core.agent import AgentRequest, AgentResponse
+from pulse.mutations import MutationTracker
+from pulse.orchestration import AgentOrchestrator
+from pulse.safety import SafetyManager
+from pulse.verification import VerificationEngine, VerificationResult
+
+
+@dataclass
+class LoopStepState:
+    step: int
+    prompt: str
+    response_content: str
+    tool_name: str | None
+    safety_approved: bool
+    verification_success: bool | None
+    mutations_count: int
+
+
+@dataclass
+class LoopResult:
+    success: bool
+    turns: int
+    final_response: str
+    history: list[LoopStepState] = field(default_factory=list)
+    verification: VerificationResult | None = None
+
+
+class AutonomousLoop:
+    """Manages multi-step autonomous execution loop for Pulse.
+
+    Loop steps:
+    1. Build ranked context via ContextManager (before each Planner/LLM call)
+    2. Evaluate step & execute via AgentOrchestrator
+    3. Check safety via SafetyManager
+    4. Run verification via VerificationEngine
+    5. Track file system mutations via MutationTracker
+    6. Checkpoint state
+    7. Invalidate the ContextManager cache so the next turn sees fresh state
+
+    The ``context_manager`` is optional.  When present its cache is invalidated
+    between turns so that each step re-builds context from up-to-date Git,
+    repository, and memory state — critical for multi-step refactoring tasks
+    where files change between turns.
+    """
+
+    def __init__(
+        self,
+        orchestrator: AgentOrchestrator,
+        safety_manager: SafetyManager | None = None,
+        verification_engine: VerificationEngine | None = None,
+        mutation_tracker: MutationTracker | None = None,
+        checkpoint_dir: Path | None = None,
+        max_steps: int = 5,
+        context_manager: ContextManager | None = None,
+    ) -> None:
+        self.orchestrator = orchestrator
+        self.safety_manager = safety_manager or getattr(orchestrator, "safety_manager", None) or SafetyManager()
+        self.verification_engine = verification_engine
+        self.mutation_tracker = mutation_tracker
+        self.checkpoint_dir = checkpoint_dir
+        self.max_steps = max_steps
+        # Prefer an explicitly supplied ContextManager; fall back to the one
+        # already wired into the orchestrator (if any).
+        self.context_manager: ContextManager | None = context_manager or getattr(
+            orchestrator, "context_manager", None
+        )
+
+    async def run(self, initial_prompt: str) -> LoopResult:
+        step_history: list[LoopStepState] = []
+        current_prompt = initial_prompt
+        last_response: AgentResponse | None = None
+        last_verification: VerificationResult | None = None
+
+        for turn in range(1, self.max_steps + 1):
+            # 1. Invalidate the context cache before each turn so that Git, repo,
+            #    and memory state changes since the previous step are picked up.
+            #    The AgentOrchestrator's handle_request() will call
+            #    context_manager.as_strings() and get a fresh build.
+            if self.context_manager and turn > 1:
+                await self.context_manager.invalidate_cache(current_prompt)
+
+            # 2. Evaluate step & execute via AgentOrchestrator
+            request = AgentRequest(message=current_prompt, metadata={"step": turn})
+            response = await self.orchestrator.handle_request(request)
+            last_response = response
+
+            # 3. Check safety via SafetyManager
+            tool_name = response.tool_name
+            safety_approved = True
+            if tool_name:
+                safety_approved = await self.safety_manager.authorize(
+                    action=tool_name,
+                    target=current_prompt,
+                    detail=f"Turn {turn} tool execution: {tool_name}",
+                )
+
+            # 4. Track mutations & verify via VerificationEngine
+            mutations_count = 0
+            verification_ok: bool | None = None
+
+            if self.mutation_tracker:
+                events = self.mutation_tracker.latest_transaction()
+                mutations_count = len(events)
+
+            if self.verification_engine:
+                last_verification = await self.verification_engine.verify()
+                verification_ok = last_verification.success
+
+            step_state = LoopStepState(
+                step=turn,
+                prompt=current_prompt,
+                response_content=response.content,
+                tool_name=tool_name,
+                safety_approved=safety_approved,
+                verification_success=verification_ok,
+                mutations_count=mutations_count,
+            )
+            step_history.append(step_state)
+
+            # 5. Checkpoint state
+            self.checkpoint_state(turn, step_history)
+
+            # Termination conditions
+            if not tool_name or not safety_approved or (verification_ok is True):
+                return LoopResult(
+                    success=safety_approved and (verification_ok is not False),
+                    turns=turn,
+                    final_response=response.content,
+                    history=step_history,
+                    verification=last_verification,
+                )
+
+            current_prompt = f"Previous step output ({tool_name}): {response.content}\nContinue task execution."
+
+        return LoopResult(
+            success=False,
+            turns=self.max_steps,
+            final_response=last_response.content if last_response else "Max steps limit reached.",
+            history=step_history,
+            verification=last_verification,
+        )
+
+    def checkpoint_state(self, step: int, history: list[LoopStepState]) -> None:
+        if not self.checkpoint_dir:
+            return
+        self.checkpoint_dir.mkdir(parents=True, exist_ok=True)
+        checkpoint_file = self.checkpoint_dir / f"checkpoint_step_{step}.json"
+        data = {
+            "step": step,
+            "history": [asdict(item) for item in history],
+        }
+        checkpoint_file.write_text(json.dumps(data, indent=2), encoding="utf-8")

pulse/production.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from collections.abc import Mapping
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from urllib.parse import urlparse
+
+from pulse.config import AgentConfig
+
+LOOPBACK_HOSTS = {"127.0.0.1", "localhost", "::1"}
+_WEAK_TOKEN_MARKERS = ("change", "default", "example", "replace", "secret", "test", "token")
+
+
+@dataclass(frozen=True, slots=True)
+class ProductionCheck:
+    name: str
+    ok: bool
+    detail: str
+    remediation: str
+    blocking: bool = True
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+
+@dataclass(frozen=True, slots=True)
+class ProductionReport:
+    target: str
+    checks: tuple[ProductionCheck, ...]
+
+    @property
+    def passed(self) -> bool:
+        return all(check.ok or not check.blocking for check in self.checks)
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "target": self.target,
+            "passed": self.passed,
+            "checks": [check.to_dict() for check in self.checks],
+        }
+
+
+def is_secure_remote_token(token: str) -> bool:
+    normalized = token.strip().lower()
+    return (
+        len(token.strip()) >= 32
+        and len(set(token.strip())) >= 12
+        and not any(marker in normalized for marker in _WEAK_TOKEN_MARKERS)
+    )
+
+
+def _inside(path: Path, parent: Path) -> bool:
+    try:
+        path.resolve().relative_to(parent.resolve())
+    except ValueError:
+        return False
+    return True
+
+
+def _integer_check(
+    checks: list[ProductionCheck],
+    environ: Mapping[str, str],
+    name: str,
+    default: int,
+    minimum: int,
+    maximum: int,
+) -> int | None:
+    raw = environ.get(name, str(default))
+    try:
+        value = int(raw)
+    except ValueError:
+        value = None
+    ok = value is not None and minimum <= value <= maximum
+    checks.append(
+        ProductionCheck(
+            name,
+            ok,
+            raw if ok else "invalid integer or outside the supported range",
+            f"Set {name} to an integer between {minimum} and {maximum}.",
+        )
+    )
+    return value
+
+
+def run_production_checks(
+    workspace: Path,
+    config: AgentConfig,
+    *,
+    provider_configured: bool,
+    target: str = "local",
+    environ: Mapping[str, str] | None = None,
+) -> ProductionReport:
+    if target not in {"local", "remote"}:
+        raise ValueError("Production target must be 'local' or 'remote'.")
+    env = environ if environ is not None else os.environ
+    root = workspace.resolve()
+    checks: list[ProductionCheck] = [
+        ProductionCheck(
+            "python_version",
+            sys.version_info >= (3, 11),
+            f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+            "Install Python 3.11 or newer.",
+        ),
+        ProductionCheck(
+            "workspace",
+            root.is_dir(),
+            str(root),
+            "Run Pulse from an existing project directory.",
+        ),
+        ProductionCheck(
+            "agent_config",
+            (root / "agent.config.json").is_file(),
+            "present" if (root / "agent.config.json").is_file() else "missing",
+            "Create agent.config.json from the documented production template.",
+        ),
+        ProductionCheck(
+            "provider_credentials",
+            provider_configured,
+            "configured" if provider_configured else "missing or placeholder",
+            "Configure the selected provider credential in the process environment or OS keyring.",
+        ),
+        ProductionCheck(
+            "model_selection",
+            bool(config.model.provider.strip() and config.model.name.strip()),
+            f"{config.model.provider}/{config.model.name}",
+            "Select an explicit provider and model with `pulse model`.",
+        ),
+        ProductionCheck(
+            "workspace_boundary",
+            _inside(config.sandbox.workspace_root, root),
+            str(config.sandbox.workspace_root),
+            "Set sandbox.workspaceRoot to the project directory or one of its descendants.",
+        ),
+        ProductionCheck(
+            "audit_log_boundary",
+            _inside(config.logging.action_log, root),
+            str(config.logging.action_log),
+            "Store the action log inside the protected project state directory.",
+        ),
+        ProductionCheck(
+            "unsafe_host_execution",
+            env.get("PULSE_UNSAFE_HOST_EXECUTION", "").lower()
+            not in {"1", "true", "yes", "on"},
+            "disabled",
+            "Unset PULSE_UNSAFE_HOST_EXECUTION; production execution must use Docker or remote isolation.",
+        ),
+    ]
+
+    pulse_path = shutil.which("pulse")
+    checks.append(
+        ProductionCheck(
+            "installed_cli",
+            pulse_path is not None,
+            pulse_path or "not found on PATH",
+            "Install the reviewed wheel with `uv tool install pulse-coding-agent`.",
+        )
+    )
+
+    container_runtime = shutil.which("docker") or shutil.which("podman")
+    checks.append(
+        ProductionCheck(
+            "container_runtime",
+            container_runtime is not None,
+            container_runtime or "not found on PATH",
+            "Install Docker or Podman before enabling model-generated command execution.",
+            blocking=target == "remote",
+        )
+    )
+
+    endpoint = env.get("PULSE_REMOTE_URL", "").strip()
+    if endpoint:
+        parsed = urlparse(endpoint)
+        endpoint_ok = parsed.scheme == "wss" or (
+            parsed.scheme == "ws" and parsed.hostname in LOOPBACK_HOSTS
+        )
+        checks.append(
+            ProductionCheck(
+                "remote_endpoint_transport",
+                endpoint_ok,
+                f"{parsed.scheme or 'missing scheme'}://{parsed.hostname or 'missing host'}",
+                "Use wss:// with mTLS, or ws:// only for a loopback endpoint.",
+            )
+        )
+
+    if target == "remote":
+        host = env.get("PULSE_REMOTE_HOST", "127.0.0.1").strip()
+        tokens = [value.strip() for value in env.get("PULSE_REMOTE_TOKEN", "").split(",") if value.strip()]
+        checks.append(
+            ProductionCheck(
+                "remote_tokens",
+                bool(tokens) and all(is_secure_remote_token(token) for token in tokens),
+                f"{len(tokens)} token(s) configured" if tokens else "missing",
+                "Generate independent random remote tokens of at least 32 characters; do not use placeholders.",
+            )
+        )
+        _integer_check(checks, env, "PULSE_REMOTE_PORT", 8080, 1, 65535)
+        _integer_check(checks, env, "PULSE_REMOTE_MAX_CONCURRENCY", 10, 1, 128)
+        _integer_check(checks, env, "PULSE_REMOTE_RETENTION_HOURS", 24, 1, 8760)
+
+        workspace_root = Path(env.get("PULSE_REMOTE_WORKSPACE_ROOT", ""))
+        database_path = Path(env.get("PULSE_REMOTE_DB", ""))
+        checks.extend(
+            [
+                ProductionCheck(
+                    "remote_workspace_root",
+                    bool(str(workspace_root)) and workspace_root.is_absolute(),
+                    str(workspace_root) or "missing",
+                    "Set PULSE_REMOTE_WORKSPACE_ROOT to a dedicated absolute volume path.",
+                ),
+                ProductionCheck(
+                    "remote_database",
+                    bool(str(database_path)) and database_path.is_absolute(),
+                    str(database_path) or "missing",
+                    "Set PULSE_REMOTE_DB to an absolute path on a backed-up durable volume.",
+                ),
+            ]
+        )
+
+        if host not in LOOPBACK_HOSTS:
+            for variable in ("PULSE_TLS_CERT", "PULSE_TLS_KEY", "PULSE_TLS_CA"):
+                value = env.get(variable, "")
+                path = Path(value) if value else None
+                checks.append(
+                    ProductionCheck(
+                        variable.lower(),
+                        bool(path and path.is_absolute() and path.is_file()),
+                        "configured" if path else "missing",
+                        f"Set {variable} to an existing absolute certificate path.",
+                    )
+                )
+
+    return ProductionReport(target=target, checks=tuple(checks))

pulse/provider.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import httpx
+
+from pulse.config import ModelConfig
+from pulse.core.protocols import LLMProvider
+from pulse.providers.anthropic import AnthropicProvider
+from pulse.providers.base import BaseProvider, ChatMessage
+from pulse.providers.deepseek import DeepSeekProvider
+from pulse.providers.gemini import GeminiProvider
+from pulse.providers.groq import GroqProvider
+from pulse.providers.openai import OpenAIProvider
+from pulse.providers.openrouter import OpenRouterProvider
+
+ModelProvider = LLMProvider
+
+
+class ProviderFactory:
+    """Create provider implementations without tying them to the CLI."""
+
+    def create(
+        self,
+        provider_name: str,
+        config: ModelConfig,
+        workspace_env_path: Path | str,
+        api_key: str | None = None,
+    ) -> BaseProvider:
+        p = provider_name.lower().strip()
+        if p == "gemini":
+            return GeminiProvider(config, workspace_env_path, api_key)
+        if p == "openrouter":
+            return OpenRouterProvider(config, workspace_env_path, api_key)
+        if p == "openai":
+            return OpenAIProvider(config, workspace_env_path, api_key)
+        if p == "anthropic":
+            return AnthropicProvider(config, workspace_env_path, api_key)
+        if p == "groq":
+            return GroqProvider(config, workspace_env_path, api_key)
+        if p == "deepseek":
+            return DeepSeekProvider(config, workspace_env_path, api_key)
+
+        raise ValueError(f"Unsupported provider: {provider_name}")
+
+
+__all__ = [
+    "AnthropicProvider",
+    "BaseProvider",
+    "ChatMessage",
+    "DeepSeekProvider",
+    "GeminiProvider",
+    "GroqProvider",
+    "ModelProvider",
+    "OpenAIProvider",
+    "OpenRouterProvider",
+    "ProviderFactory",
+    "httpx",
+]