orbit-cli 0.1.0__py3-none-any.whl

orbit/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

orbit/agent/ask.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from orbit.config import get_config
+from orbit.context.scanner import scan
+from orbit.llm.ollama_provider import OllamaProvider
+from orbit.ui.console import console
+
+ASK_SYSTEM_PROMPT = """You are a helpful DevOps assistant. Answer questions about the user's
+environment based on the provided context. Be concise and specific.
+If you're not sure, say so. Do not execute any commands."""
+
+
+async def ask(question: str) -> None:
+    """Answer a question about the environment. No execution."""
+    config = get_config()
+    provider = OllamaProvider(host=config.ollama_host, port=config.ollama_port)
+
+    console.print("[orbit.blue]Scanning environment...[/]")
+    env = await scan()
+
+    context_parts = [f"[{slot.source}]\n{slot.content}" for slot in env.slots if slot.available]
+    context_text = "\n\n".join(context_parts) if context_parts else "No context available."
+
+    messages = [
+        {"role": "system", "content": ASK_SYSTEM_PROMPT},
+        {"role": "user", "content": f"Environment:\n{context_text}\n\nQuestion: {question}"},
+    ]
+
+    try:
+        # Stream the response
+        response = provider.chat(model=config.default_model, messages=messages, temperature=0.3)
+        console.print()
+        console.print(str(response))
+    except Exception as e:
+        console.print(f"[orbit.error]Error: {e}[/]")

orbit/agent/budget.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+
+class BudgetExhaustedError(Exception):
+    """Raised when an agent budget limit is exceeded."""
+
+    def __init__(self, resource: str, used: int, limit: int) -> None:
+        self.resource = resource
+        self.used = used
+        self.limit = limit
+        super().__init__(f"Budget exhausted: {resource} ({used}/{limit})")
+
+
+class Budget:
+    """Tracks agent loop resource usage with hard limits."""
+
+    def __init__(
+        self,
+        max_steps: int = 15,
+        max_replans_per_step: int = 3,
+        max_llm_calls: int = 25,
+    ) -> None:
+        self.max_steps = max_steps
+        self.max_replans_per_step = max_replans_per_step
+        self.max_llm_calls = max_llm_calls
+        self._steps = 0
+        self._replans_current_step = 0
+        self._total_replans = 0
+        self._llm_calls = 0
+
+    def use_step(self) -> None:
+        self._steps += 1
+        self._replans_current_step = 0
+        if self._steps > self.max_steps:
+            raise BudgetExhaustedError("steps", self._steps, self.max_steps)
+
+    def use_replan(self) -> None:
+        self._replans_current_step += 1
+        self._total_replans += 1
+        if self._replans_current_step > self.max_replans_per_step:
+            raise BudgetExhaustedError("replans_per_step", self._replans_current_step, self.max_replans_per_step)
+
+    def use_llm_call(self) -> None:
+        self._llm_calls += 1
+        if self._llm_calls > self.max_llm_calls:
+            raise BudgetExhaustedError("llm_calls", self._llm_calls, self.max_llm_calls)
+
+    def can_replan(self) -> bool:
+        return self._replans_current_step < self.max_replans_per_step and self._llm_calls < self.max_llm_calls
+
+    def usage(self) -> dict[str, int]:
+        return {
+            "steps": self._steps,
+            "total_replans": self._total_replans,
+            "llm_calls": self._llm_calls,
+            "max_steps": self.max_steps,
+            "max_llm_calls": self.max_llm_calls,
+        }

orbit/agent/executor.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import asyncio
+import subprocess
+import time
+
+from orbit.schemas.execution import CommandResult
+from orbit.schemas.plan import PlanStep
+from orbit.ui.console import console
+
+
+async def run(step: PlanStep, stream: bool = True) -> CommandResult:
+    """Execute a command with streaming output and timeout."""
+    start = time.monotonic()
+
+    try:
+        if stream:
+            return await _run_streaming(step, start)
+        else:
+            return await _run_simple(step, start)
+    except TimeoutError:
+        duration = time.monotonic() - start
+        return CommandResult(
+            command=step.command,
+            exit_code=-1,
+            stdout="",
+            stderr=f"Command timed out after {step.timeout_seconds}s",
+            duration_seconds=duration,
+            timed_out=True,
+        )
+
+
+async def _run_streaming(step: PlanStep, start: float) -> CommandResult:
+    """Run with streaming stdout to terminal."""
+    proc = await asyncio.create_subprocess_shell(
+        step.command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+
+    stdout_lines: list[str] = []
+    stderr_lines: list[str] = []
+
+    async def read_stream(stream: asyncio.StreamReader | None, lines: list[str], display: bool) -> None:
+        if stream is None:
+            return
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            decoded = line.decode("utf-8", errors="replace")
+            lines.append(decoded)
+            if display:
+                console.print(f"  [dim]{decoded.rstrip()}[/]")
+
+    try:
+        await asyncio.wait_for(
+            asyncio.gather(
+                read_stream(proc.stdout, stdout_lines, True),
+                read_stream(proc.stderr, stderr_lines, False),
+                proc.wait(),
+            ),
+            timeout=step.timeout_seconds,
+        )
+    except TimeoutError:
+        proc.kill()
+        raise
+
+    duration = time.monotonic() - start
+    return CommandResult(
+        command=step.command,
+        exit_code=proc.returncode if proc.returncode is not None else -1,
+        stdout="".join(stdout_lines),
+        stderr="".join(stderr_lines),
+        duration_seconds=duration,
+    )
+
+
+async def _run_simple(step: PlanStep, start: float) -> CommandResult:
+    """Run without streaming, capture all output."""
+    loop = asyncio.get_event_loop()
+    result = await loop.run_in_executor(
+        None,
+        lambda: subprocess.run(
+            step.command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=step.timeout_seconds,
+        ),
+    )
+    duration = time.monotonic() - start
+    return CommandResult(
+        command=step.command,
+        exit_code=result.returncode,
+        stdout=result.stdout,
+        stderr=result.stderr,
+        duration_seconds=duration,
+    )

orbit/agent/loop.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import time
+
+from orbit.agent import budget as budget_mod
+from orbit.agent import executor, observer, planner
+from orbit.config import OrbitConfig, get_config
+from orbit.context.scanner import scan
+from orbit.llm.ollama_provider import OllamaProvider
+from orbit.router import context_budget, decomposer, model_selector
+from orbit.router.model_registry import ModelRegistry
+from orbit.safety.classifier import classify
+from orbit.schemas.execution import ExecutionRecord
+from orbit.ui.confirmations import confirm_step
+from orbit.ui.console import console
+from orbit.ui.panels import show_fatal, show_plan, show_replan, show_step_success, show_summary
+
+
+async def run(goal: str, config: OrbitConfig | None = None) -> list[ExecutionRecord]:
+    """Execute the full agent loop: scan → decompose → plan → confirm → execute → observe."""
+    if config is None:
+        config = get_config()
+
+    budget = budget_mod.Budget(
+        max_steps=config.max_steps,
+        max_replans_per_step=config.max_replans,
+        max_llm_calls=config.max_llm_calls,
+    )
+    provider = OllamaProvider(host=config.ollama_host, port=config.ollama_port)
+
+    # 1. Scan environment
+    console.print("[orbit.blue]Scanning environment...[/]")
+    env = await scan()
+
+    # 2. Scan models and build registry
+    registry = ModelRegistry()
+    try:
+        registry.scan(provider)
+    except Exception as e:
+        show_fatal(f"Cannot connect to Ollama: {e}")
+        return []
+
+    # 3. Decompose goal
+    console.print("[orbit.blue]Decomposing goal...[/]")
+    budget.use_llm_call()
+    decomposition = await decomposer.decompose(goal, env, provider, config.default_model)
+
+    # 4. Select models
+    model_map = model_selector.select(decomposition, registry, config.default_model)
+
+    # 5. Allocate context budget
+    ctx_window = registry.get_context_window(config.default_model)
+    ctx_budget = context_budget.create_budget(ctx_window)
+    env.slots = context_budget.allocate(env.slots, ctx_budget)
+
+    # 6. Generate plan
+    console.print("[orbit.blue]Generating plan...[/]")
+    execution_plan = await planner.plan(goal, decomposition, env, model_map, budget, provider)
+
+    if not execution_plan.steps:
+        show_fatal("Could not generate an execution plan.")
+        return []
+
+    # 7. Show plan
+    show_plan(execution_plan)
+
+    # 8. Execute steps
+    records: list[ExecutionRecord] = []
+    start_time = time.monotonic()
+    i = 0
+
+    try:
+        while i < len(execution_plan.steps):
+            step = execution_plan.steps[i]
+            budget.use_step()
+
+            # Safety gate
+            risk = classify(step.command, env)
+            if not confirm_step(step, risk):
+                console.print(f"  [orbit.warning]Skipped: {step.description}[/]")
+                i += 1
+                continue
+
+            # Execute
+            result = await executor.run(step)
+            record = ExecutionRecord(
+                step=step,
+                result=result,
+                rollback_available=step.rollback_command is not None,
+            )
+            records.append(record)
+
+            # Record to history
+            try:
+                from orbit.memory.history import record as record_history
+
+                record_history(result, goal=goal)
+            except Exception:
+                pass  # history recording is best-effort
+
+            # Observe
+            decision = observer.analyze(step, result, budget)
+
+            if decision.status == "success":
+                show_step_success(step, result)
+                i += 1
+            elif decision.status == "replan":
+                show_replan(decision.analysis)
+                budget.use_replan()
+                new_plan = await planner.replan(
+                    goal, records, decision.analysis, env, budget, provider, config.default_model
+                )
+                if new_plan.steps:
+                    # Replace remaining steps with replan output
+                    execution_plan.steps[i:] = new_plan.steps
+                else:
+                    i += 1
+            elif decision.status == "fatal":
+                show_fatal(decision.analysis)
+                break
+
+    except budget_mod.BudgetExhaustedError as e:
+        show_fatal(f"Budget exhausted: {e}")
+
+    duration = time.monotonic() - start_time
+    completed = sum(1 for r in records if r.result.exit_code == 0)
+    show_summary(completed, len(execution_plan.steps), duration)
+
+    return records

orbit/agent/observer.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from orbit.agent.budget import Budget
+from orbit.schemas.execution import CommandResult
+from orbit.schemas.plan import PlanStep
+
+
+@dataclass
+class ObserverDecision:
+    """Decision from the observer about how to proceed."""
+
+    status: str  # "success", "replan", "fatal"
+    analysis: str
+    suggested_fix: str | None = None
+
+
+def analyze(step: PlanStep, result: CommandResult, budget: Budget) -> ObserverDecision:
+    """Analyze a step result and decide: success / replan / fatal. Deterministic, no LLM."""
+    if result.timed_out:
+        return ObserverDecision("fatal", f"Command timed out after {step.timeout_seconds}s: {step.command}")
+
+    if result.exit_code == step.expected_exit_code:
+        if step.expected_output_pattern:
+            if re.search(step.expected_output_pattern, result.stdout):
+                return ObserverDecision("success", "Command succeeded with expected output.")
+            return ObserverDecision(
+                "success",
+                f"Command succeeded (exit 0) but output did not match pattern '{step.expected_output_pattern}'.",
+            )
+        return ObserverDecision("success", "Command succeeded.")
+
+    error_summary = (result.stderr[:500] if result.stderr else result.stdout[:500]) or "(no output)"
+    if budget.can_replan():
+        return ObserverDecision("replan", f"Command failed (exit {result.exit_code}): {error_summary}")
+
+    msg = f"Command failed (exit {result.exit_code}), replan budget exhausted: {error_summary}"
+    return ObserverDecision("fatal", msg)

orbit/agent/planner.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from orbit.agent.budget import Budget
+from orbit.llm.base import BaseLLM, LLMValidationError
+from orbit.schemas.context import EnvironmentState
+from orbit.schemas.execution import ExecutionRecord
+from orbit.schemas.plan import Plan, TaskDecomposition
+
+PLANNER_SYSTEM_PROMPT = """You are a DevOps execution planner. Given a goal, environment context,
+and task decomposition, generate a concrete execution plan.
+
+Rules:
+- Each step must have a real shell command
+- Set appropriate risk_level: safe (read-only), caution (modifying), destructive (data loss), nuclear (catastrophic)
+- Add rollback_command for any destructive or caution step where possible
+- Set realistic timeout_seconds (default 30, longer for builds/deploys)
+- Use expected_output_pattern (regex) when you know what success looks like
+- Keep plans minimal: fewest steps to achieve the goal
+
+Respond ONLY as JSON matching the provided schema."""
+
+REPLAN_SYSTEM_PROMPT = """You are a DevOps replanner. A step in the execution plan failed.
+Given the original goal, what was accomplished so far, and the error,
+generate replacement steps to complete the goal.
+
+Rules:
+- Do NOT re-run steps that already succeeded
+- Address the error directly
+- Keep the remaining plan minimal
+- If the error is unrecoverable, return an empty plan
+
+Respond ONLY as JSON matching the provided schema."""
+
+
+async def plan(
+    goal: str,
+    decomposition: TaskDecomposition,
+    env: EnvironmentState,
+    model_map: dict[str, str],
+    budget: Budget,
+    provider: BaseLLM,
+) -> Plan:
+    """Generate an execution plan using LLM structured output."""
+    budget.use_llm_call()
+
+    planning_model = model_map.get("reasoning", model_map.get("general", "qwen2.5:7b"))
+
+    subtask_descriptions = "\n".join(
+        f"- {st.description} (capability: {st.capability})" for st in decomposition.subtasks
+    )
+    context_text = _build_context(env)
+
+    messages = [
+        {"role": "system", "content": PLANNER_SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": f"Goal: {goal}\n\nSubtasks:\n{subtask_descriptions}\n\nEnvironment:\n{context_text}",
+        },
+    ]
+
+    try:
+        result = await provider.achat(model=planning_model, messages=messages, schema=Plan, temperature=0.0)
+        if isinstance(result, Plan):
+            result.goal = goal
+            return result
+    except LLMValidationError:
+        pass
+
+    return Plan(goal=goal, steps=[])
+
+
+async def replan(
+    goal: str,
+    records: list[ExecutionRecord],
+    error_analysis: str,
+    env: EnvironmentState,
+    budget: Budget,
+    provider: BaseLLM,
+    model: str,
+) -> Plan:
+    """Generate replacement steps after a failure."""
+    budget.use_llm_call()
+    budget.use_replan()
+
+    completed_summary = "\n".join(
+        f"- {r.step.description}: {'OK' if r.result.exit_code == 0 else 'FAILED'}" for r in records
+    )
+
+    messages = [
+        {"role": "system", "content": REPLAN_SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": (
+                f"Goal: {goal}\n\nCompleted steps:\n{completed_summary}\n\n"
+                f"Error: {error_analysis}\n\nEnvironment:\n{_build_context(env)}"
+            ),
+        },
+    ]
+
+    try:
+        result = await provider.achat(model=model, messages=messages, schema=Plan, temperature=0.0)
+        if isinstance(result, Plan):
+            return result
+    except LLMValidationError:
+        pass
+
+    return Plan(goal=goal, steps=[])
+
+
+def _build_context(env: EnvironmentState) -> str:
+    parts = [f"[{slot.source}]\n{slot.content}" for slot in env.slots if slot.available and slot.estimated_tokens > 0]
+    return "\n\n".join(parts) if parts else "No context available."

orbit/agent/wtf.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import os
+
+from orbit.config import get_config
+from orbit.llm.base import LLMValidationError
+from orbit.llm.ollama_provider import OllamaProvider
+from orbit.modules.registry import get_all_modules, load_builtin_modules
+from orbit.schemas.analysis import WtfAnalysis
+from orbit.ui.console import console
+
+WTF_SYSTEM_PROMPT = """You are a DevOps error diagnostician. Given a failed command and its output,
+explain the error, identify the root cause, and suggest a fix command.
+
+Be specific and actionable. If you're not confident, say so.
+Respond ONLY as JSON matching the provided schema."""
+
+
+async def diagnose() -> None:
+    """Diagnose the last failed command."""
+    load_builtin_modules()
+
+    # Try to get last command from environment
+    last_cmd = os.environ.get("ORBIT_LAST_COMMAND")
+    last_stderr = os.environ.get("ORBIT_LAST_STDERR", "")
+    last_stdout = os.environ.get("ORBIT_LAST_STDOUT", "")
+    last_exit = os.environ.get("ORBIT_LAST_EXIT_CODE", "")
+
+    if not last_cmd:
+        # Try history
+        try:
+            from orbit.memory.history import get_last_failed
+
+            failed = get_last_failed()
+            if failed:
+                last_cmd = failed["command"]
+                last_stderr = failed.get("stderr", "")
+                last_stdout = failed.get("stdout", "")
+                last_exit = str(failed.get("exit_code", ""))
+        except Exception:
+            pass
+
+    if not last_cmd:
+        console.print("[orbit.warning]No failed command found. Run a command first, then try orbit wtf.[/]")
+        return
+
+    console.print(f"[orbit.blue]Diagnosing:[/] {last_cmd}")
+
+    # Fast path: check module failure patterns
+    for module in get_all_modules():
+        for pattern, explanation in module.get_common_failures().items():
+            if pattern in last_stderr or pattern in last_stdout:
+                console.print()
+                from rich.panel import Panel
+
+                console.print(
+                    Panel(
+                        f"[orbit.error]Error:[/] {pattern}\n\n[orbit.warning]Explanation:[/] {explanation}",
+                        title=f"[orbit.blue]{module.name} module[/]",
+                        border_style="orbit.blue",
+                    )
+                )
+                return
+
+    # Slow path: LLM diagnosis
+    config = get_config()
+    provider = OllamaProvider(host=config.ollama_host, port=config.ollama_port)
+
+    error_context = (
+        f"Command: {last_cmd}\nExit code: {last_exit}\nStderr: {last_stderr[:1000]}\nStdout: {last_stdout[:1000]}"
+    )
+
+    messages = [
+        {"role": "system", "content": WTF_SYSTEM_PROMPT},
+        {"role": "user", "content": error_context},
+    ]
+
+    try:
+        result = await provider.achat(
+            model=config.default_model, messages=messages, schema=WtfAnalysis, temperature=0.0
+        )
+        if isinstance(result, WtfAnalysis):
+            _display_analysis(result)
+    except (LLMValidationError, Exception) as e:
+        console.print(f"[orbit.error]Could not diagnose: {e}[/]")
+
+
+def _display_analysis(analysis: WtfAnalysis) -> None:
+    from rich.panel import Panel
+
+    parts = [
+        f"[orbit.error]Error:[/] {analysis.error_explanation}",
+        f"[orbit.warning]Root cause:[/] {analysis.root_cause}",
+        f"[dim]Confidence: {analysis.confidence:.0%}[/]",
+    ]
+    if analysis.fix_command:
+        parts.append(f"\n[orbit.success]Fix:[/] [orbit.command]{analysis.fix_command}[/]")
+        parts.append(f"[dim]{analysis.fix_explanation}[/]")
+
+    console.print()
+    console.print(Panel("\n".join(parts), title="[orbit.blue]Diagnosis[/]", border_style="orbit.blue"))