bareagent-cli 0.1.0__py3-none-any.whl

bareagent/core/context.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import subprocess
+from datetime import date
+from functools import lru_cache
+from pathlib import Path
+
+BASE_SYSTEM_PROMPT = "You are BareAgent, a terminal-based coding assistant."
+
+# Injected into the system context only while the permission mode is PLAN
+# (see ``main.py:_refresh_plan_directive``). Tells the model how the plan-mode
+# workflow works: research read-only, then present a plan via ``exit_plan_mode``
+# rather than blindly attempting write tools (which PLAN blocks).
+PLAN_MODE_DIRECTIVE = (
+    "You are in PLAN mode. Investigate and design only -- do NOT modify files, "
+    "run state-changing commands, or perform other side effects. Use the "
+    "read-only tools (read_file, glob, grep, web_fetch, web_search, load_skill) "
+    "to research the task thoroughly.\n"
+    "When your implementation plan is ready, call the exit_plan_mode tool with "
+    "the full plan as markdown to present it for approval. That tool is the only "
+    "way to leave plan mode -- do not ask for approval in plain prose.\n"
+    "If the user approves, the permission mode switches and you continue with the "
+    "implementation in this same conversation. If the user rejects, you stay in "
+    "PLAN mode: revise the plan using their feedback and call exit_plan_mode again."
+)
+
+
+def _normalize_workspace(workspace: Path) -> Path:
+    return workspace.expanduser().resolve()
+
+
+def _run_git_command(workspace: Path, *args: str) -> str:
+    completed = subprocess.run(
+        ["git", *args],
+        cwd=workspace,
+        capture_output=True,
+        check=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        timeout=5,
+    )
+    return completed.stdout.strip()
+
+
+@lru_cache(maxsize=1)
+def _get_system_context_cached(workspace: Path) -> str:
+    try:
+        branch = _run_git_command(workspace, "branch", "--show-current") or "detached"
+    except (OSError, subprocess.SubprocessError):
+        branch = "unknown"
+
+    try:
+        recent_commits = (
+            _run_git_command(workspace, "log", "--oneline", "-3") or "No commits found."
+        )
+    except (OSError, subprocess.SubprocessError):
+        recent_commits = "No commits found." if branch != "unknown" else "Unavailable."
+
+    return "\n".join(
+        [
+            f"Git branch: {branch}",
+            "Recent commits:",
+            recent_commits,
+        ]
+    )
+
+
+def get_system_context(workspace: Path | None = None) -> str:
+    """Return git metadata for the requested workspace without repeating git calls."""
+    resolved_workspace = _normalize_workspace(workspace or Path.cwd())
+    cached = _get_system_context_cached(resolved_workspace)
+    return f"{cached}\nDate: {date.today().isoformat()}"
+
+
+def _read_context_file(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+
+
+def get_user_context(workspace: Path) -> str:
+    """Load global and workspace-level BAREAGENT.md files."""
+    workspace = _normalize_workspace(workspace)
+    context_files = [
+        Path.home() / ".bareagent" / "BAREAGENT.md",
+        workspace / "BAREAGENT.md",
+    ]
+
+    sections: list[str] = []
+    for path in context_files:
+        content = _read_context_file(path)
+        if content:
+            sections.append(f"# From {path}\n{content}")
+
+    return "\n\n".join(sections)
+
+
+def assemble_system_prompt(
+    workspace: Path,
+    skill_summary: str = "",
+    nag_reminder: str = "",
+    memory_context: str = "",
+) -> str:
+    """Assemble the full system prompt from dynamic context fragments."""
+    workspace = _normalize_workspace(workspace)
+    sections = [
+        BASE_SYSTEM_PROMPT,
+        f"Workspace: {workspace}",
+        get_system_context(workspace),
+    ]
+
+    user_context = get_user_context(workspace)
+    if user_context:
+        sections.append(f"<user-instructions>\n{user_context}\n</user-instructions>")
+
+    if memory_context.strip():
+        sections.append(memory_context.strip())
+
+    if skill_summary.strip():
+        sections.append(f"<skill-summary>\n{skill_summary.strip()}\n</skill-summary>")
+
+    if nag_reminder.strip():
+        sections.append(f"<nag-reminder>\n{nag_reminder.strip()}\n</nag-reminder>")
+
+    return "\n\n".join(sections)

bareagent/core/fileutil.py

@@ -0,0 +1,103 @@
+"""Shared file-system and small utilities."""
+
+from __future__ import annotations
+
+import json
+import os
+import secrets
+import string
+import tempfile
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+_ID_ALPHABET = string.ascii_letters + string.digits
+
+
+def stringify(value: Any) -> str:
+    """Convert any value to a string suitable for tool output or serialization."""
+    if isinstance(value, str):
+        return value
+    if value is None:
+        return ""
+    return json.dumps(value, ensure_ascii=False, default=str)
+
+
+def generate_random_id(length: int = 8) -> str:
+    """Return a cryptographically random alphanumeric string."""
+    return "".join(secrets.choice(_ID_ALPHABET) for _ in range(length))
+
+
+def is_tool_result_message(msg: dict[str, Any]) -> bool:
+    """Check whether a message contains tool_result blocks."""
+    content = msg.get("content")
+    return isinstance(content, list) and any(
+        isinstance(block, dict) and block.get("type") == "tool_result" for block in content
+    )
+
+
+def atomic_write_json(file_path: Path, payload: Any) -> None:
+    """Atomically write *payload* as JSON to *file_path* via tempfile + rename."""
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp_path = tempfile.mkstemp(dir=str(file_path.parent), suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(payload, f, ensure_ascii=False, indent=2)
+        os.replace(tmp_path, str(file_path))
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def atomic_write_text(file_path: Path, text: str) -> None:
+    """Atomically write *text* to *file_path* via tempfile + rename.
+
+    Text counterpart of :func:`atomic_write_json` for persistent Markdown
+    state (memory files, MEMORY.md). ``newline="\\n"`` keeps line endings
+    stable across platforms so ``str_replace`` / ``insert`` matching is
+    deterministic on Windows and POSIX alike.
+    """
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp_path = tempfile.mkstemp(dir=str(file_path.parent), suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as f:
+            f.write(text)
+        os.replace(tmp_path, str(file_path))
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def utc_timestamp_iso() -> str:
+    """Return the current UTC time as an ISO-8601 string."""
+    return datetime.now(UTC).isoformat()
+
+
+def optional_string(value: Any) -> str | None:
+    """Normalize *value* to a stripped string, or ``None`` if blank/None."""
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def collect_tool_names(messages: list[dict[str, Any]]) -> dict[str, str]:
+    """Build a mapping from tool_use id → tool name across all messages."""
+    tool_name_by_id: dict[str, str] = {}
+    for message in messages:
+        content = message.get("content")
+        if not isinstance(content, list):
+            continue
+        for block in content:
+            if not isinstance(block, dict) or block.get("type") != "tool_use":
+                continue
+            tool_id = str(block.get("id", ""))
+            if tool_id:
+                tool_name_by_id[tool_id] = str(block.get("name", "unknown"))
+    return tool_name_by_id

bareagent/core/goal.py

@@ -0,0 +1,214 @@
+"""Goal completion loop: drive turns until an evaluator judges a condition met.
+
+Pure logic with no LLM / loop / REPL / SDK dependencies, so the loop driver,
+verdict parsing, prompt construction, and command parsing are fully unit-testable
+with injected callbacks (mirrors the ``src/core/retry.py`` and
+``src/planning/skill_gen.py`` pure-module pattern).
+
+Division of labor (see task 06-06-goal-completion-loop):
+- This module owns the *control flow*: how prompts are sequenced, when to stop,
+  and why (``run_goal_loop``), plus the pure text/parse helpers.
+- The REPL (``main.py``) owns the side-effecting parts: running the real
+  ``agent_loop`` turn and the isolated evaluator LLM call, which it injects into
+  :func:`run_goal_loop` as the ``run_turn`` / ``evaluate`` callbacks.
+
+The loop is *synchronous and non-persistent*: ``/goal <condition>`` blocks the
+REPL, drives turns until the condition is met or ``max_turns`` is hit, then
+returns. There is no cross-input goal state (persistence is out of scope), so the
+driver only needs the condition and the turn budget.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import Enum
+
+DEFAULT_MAX_TURNS = 25
+
+GOAL_USAGE = (
+    "Usage: /goal [--max-turns N] <completion condition>\n"
+    "  Drives the agent turn-after-turn until an independent evaluator judges "
+    "the condition met (or the turn budget is exhausted).\n"
+    "  Example: /goal all tests in tests/test_goal.py pass and ruff is clean\n"
+    "  The evaluator judges only from the transcript, so state a check the agent "
+    "can show evidence for (e.g. run pytest and include the exit code)."
+)
+
+
+class GoalOutcome(Enum):
+    """Why :func:`run_goal_loop` stopped. ABORTED is set by the caller (the loop
+    itself only returns MET / MAX_TURNS; interrupts propagate out of the injected
+    callbacks for the caller to translate)."""
+
+    MET = "met"
+    MAX_TURNS = "max_turns"
+    ABORTED = "aborted"
+
+
+@dataclass(slots=True)
+class GoalState:
+    """Runtime state for one ``/goal`` invocation."""
+
+    condition: str
+    max_turns: int = DEFAULT_MAX_TURNS
+    turns_used: int = 0
+
+
+@dataclass(slots=True)
+class Verdict:
+    """An evaluator's judgement on whether the condition is satisfied.
+
+    ``malformed`` flags a verdict that the evaluator failed to produce cleanly
+    (LLM error, no tool call, missing field). A malformed verdict is always
+    treated as *not met* so the loop falls through to its ``max_turns`` guard
+    instead of crashing or stopping early.
+    """
+
+    met: bool
+    reason: str = ""
+    malformed: bool = False
+
+
+@dataclass(slots=True)
+class GoalCommand:
+    """Parsed ``/goal`` command. ``action`` is ``"run" | "usage" | "error"``."""
+
+    action: str
+    condition: str = ""
+    max_turns: int = DEFAULT_MAX_TURNS
+    message: str = ""  # usage / error text for the non-run actions
+
+
+def _coerce_bool(value: object) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.strip().lower() in {"true", "1", "yes", "y"}
+    return bool(value)
+
+
+def parse_verdict(tool_input: dict | None) -> Verdict:
+    """Coerce a ``goal_verdict`` tool input into a :class:`Verdict` defensively.
+
+    A missing/absent ``met`` field yields a malformed (= not met) verdict rather
+    than guessing, so a confused evaluator never accidentally reports success.
+    """
+    if not isinstance(tool_input, dict):
+        return Verdict(met=False, reason="", malformed=True)
+    reason = str(tool_input.get("reason", "") or "").strip()
+    if "met" not in tool_input or tool_input.get("met") is None:
+        return Verdict(met=False, reason=reason, malformed=True)
+    return Verdict(met=_coerce_bool(tool_input.get("met")), reason=reason)
+
+
+def build_initial_prompt(condition: str) -> str:
+    """User message that kicks off the self-driving loop (turn 1)."""
+    return (
+        "Work autonomously toward the goal below until it is fully satisfied. "
+        "After each step an independent evaluator checks whether the condition is "
+        "met and tells you what is still missing.\n\n"
+        f"<goal-condition>\n{condition.strip()}\n</goal-condition>\n\n"
+        "Make concrete progress now. When you believe the condition is met, run "
+        "the relevant checks and include their output so it can be verified from "
+        "this conversation."
+    )
+
+
+def build_evaluator_prompt(condition: str) -> str:
+    """User message appended to the transcript COPY for the isolated evaluator."""
+    return (
+        "You are a strict goal-completion evaluator. The conversation above shows "
+        "an agent working toward this completion condition:\n\n"
+        f"<goal-condition>\n{condition.strip()}\n</goal-condition>\n\n"
+        "Judge ONLY from the conversation above whether the condition is now fully "
+        "satisfied. Do not assume work that is not shown: if success is claimed but "
+        "the supporting evidence (tool results, command output) is not present in "
+        "the transcript, treat it as NOT met.\n\n"
+        "Call the `goal_verdict` tool exactly once:\n"
+        "- met=true only if the condition is fully and verifiably satisfied.\n"
+        "- met=false otherwise, with a concrete `reason` naming what is still "
+        "missing and what the agent should do next.\n"
+        "Output nothing else."
+    )
+
+
+def build_continuation_prompt(reason: str) -> str:
+    """User message fed back to the main loop when the goal is not yet met."""
+    base = "The goal is not yet satisfied."
+    reason = (reason or "").strip()
+    if reason:
+        base += f" Evaluator feedback: {reason}"
+    return base + " Keep working toward the goal."
+
+
+def parse_goal_command(rest: str, *, default_max_turns: int = DEFAULT_MAX_TURNS) -> GoalCommand:
+    """Parse the text after ``/goal`` into a :class:`GoalCommand`.
+
+    Forms: ``""`` -> usage; ``--max-turns N <condition>`` -> run with override;
+    ``<condition>`` -> run with the default budget. Pure (no I/O) so it is
+    directly unit-testable.
+    """
+    rest = (rest or "").strip()
+    if not rest:
+        return GoalCommand(action="usage", message=GOAL_USAGE)
+
+    max_turns = default_max_turns
+    if rest.startswith("--max-turns"):
+        parts = rest.split(None, 2)  # ["--max-turns", "N", "<condition...>"]
+        if len(parts) < 3:
+            return GoalCommand(action="error", message="Usage: /goal [--max-turns N] <condition>")
+        try:
+            max_turns = int(parts[1])
+        except ValueError:
+            return GoalCommand(
+                action="error",
+                message=f"Invalid --max-turns value: {parts[1]!r} (expected an integer).",
+            )
+        if max_turns < 1:
+            return GoalCommand(action="error", message="--max-turns must be >= 1.")
+        condition = parts[2].strip()
+    else:
+        condition = rest
+
+    if not condition:
+        return GoalCommand(
+            action="error", message="Provide a completion condition: /goal <condition>"
+        )
+    return GoalCommand(action="run", condition=condition, max_turns=max_turns)
+
+
+def run_goal_loop(
+    state: GoalState,
+    *,
+    run_turn: Callable[[str], None],
+    evaluate: Callable[[], Verdict],
+    on_progress: Callable[[str], None] | None = None,
+) -> tuple[GoalOutcome, Verdict | None]:
+    """Drive turns until the condition is met or the turn budget is exhausted.
+
+    - ``run_turn(prompt)`` runs one real agent turn (appends ``prompt`` as a user
+      message and runs ``agent_loop`` to completion). It owns its own rollback on
+      failure and may raise (e.g. ``LLMCallError`` / ``KeyboardInterrupt``); such
+      exceptions propagate out of this function for the caller to treat as
+      ``ABORTED``.
+    - ``evaluate()`` runs the isolated evaluator and returns a :class:`Verdict`.
+      It must NOT raise for ordinary evaluator failures (return a malformed,
+      not-met verdict instead); only a user interrupt should propagate.
+
+    Returns ``(outcome, last_verdict)``. ``last_verdict`` is ``None`` only if the
+    loop never ran (``max_turns < 1``, which the command parser already rejects).
+    """
+    last: Verdict | None = None
+    prompt = build_initial_prompt(state.condition)
+    while state.turns_used < state.max_turns:
+        state.turns_used += 1
+        if on_progress is not None:
+            on_progress(f"Goal turn {state.turns_used}/{state.max_turns}...")
+        run_turn(prompt)
+        verdict = evaluate()
+        last = verdict
+        if verdict.met:
+            return GoalOutcome.MET, verdict
+        prompt = build_continuation_prompt(verdict.reason)
+    return GoalOutcome.MAX_TURNS, last

bareagent/core/handlers/__init__.py

@@ -0,0 +1 @@
+"""Tool handlers for BareAgent."""

bareagent/core/handlers/bash.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+
+def run_bash(
+    command: str,
+    timeout: int = 30,
+    *,
+    cwd: Path | None = None,
+    raise_on_error: bool = False,
+) -> str:
+    """Run a shell command and return combined stdout/stderr."""
+    if os.name == "nt":
+        # Windows PowerShell 5.1 on a Chinese locale writes stdout/stderr as
+        # GBK(cp936) by default; the Python side decodes as UTF-8 below, so we
+        # force the console output encoding to UTF-8 to keep both ends aligned
+        # (otherwise Chinese cmdlet output/errors decode into U+FFFD). The setter
+        # is wrapped in try/catch so an environment that rejects it never blocks
+        # the actual command from running.
+        windows_prefix = (
+            "try { [Console]::OutputEncoding = [System.Text.Encoding]::UTF8 } "
+            "catch {}; "
+        )
+        completed_command = [
+            "powershell",
+            "-NoProfile",
+            "-Command",
+            windows_prefix + command,
+        ]
+    else:
+        completed_command = ["bash", "-lc", command]
+
+    try:
+        result = subprocess.run(
+            completed_command,
+            capture_output=True,
+            timeout=timeout,
+            check=False,
+            cwd=None if cwd is None else str(cwd),
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except subprocess.TimeoutExpired as exc:
+        output = _join_output(exc.stdout, exc.stderr)
+        if output:
+            message = f"Error: command timed out after {timeout} seconds\n{output}"
+        else:
+            message = f"Error: command timed out after {timeout} seconds"
+        if raise_on_error:
+            raise RuntimeError(message) from exc
+        return message
+
+    output = _join_output(result.stdout, result.stderr)
+    if result.returncode != 0:
+        if output:
+            message = f"Command failed with exit code {result.returncode}\n{output}"
+        else:
+            message = f"Command failed with exit code {result.returncode}"
+        if raise_on_error:
+            raise RuntimeError(message)
+        return message
+    return output
+
+
+def _join_output(stdout: str | bytes | None, stderr: str | bytes | None) -> str:
+    parts: list[str] = []
+    for value in (stdout, stderr):
+        if value is None:
+            continue
+        if isinstance(value, bytes):
+            value = value.decode("utf-8", errors="replace")
+        text = value.rstrip()
+        if text:
+            parts.append(text)
+    return "\n".join(parts)

bareagent/core/handlers/file_edit.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from bareagent.core.sandbox import safe_path
+
+
+def run_edit(
+    file_path: str,
+    old_text: str,
+    new_text: str,
+    *,
+    workspace: Path,
+    diagnostics_hook: Callable[[str, Any], str | None] | None = None,
+) -> str:
+    """Replace the first matching block of text in a workspace file.
+
+    ``diagnostics_hook`` is the Hybrid auto-diagnostics callback supplied by
+    ``get_handlers`` when LSP is active. The handler invokes it before and
+    after the write so any newly-introduced diagnostics can be appended to
+    the tool result. The hook signature is
+    ``(file_path, before) -> str | None`` — passing ``before=None`` on the
+    pre-edit call lets the hook implementation produce its own snapshot,
+    and ``None`` is returned whenever LSP is unavailable or the config flag
+    is off so the happy path stays zero-cost.
+    """
+    resolved = safe_path(file_path, workspace)
+    current = resolved.read_text(encoding="utf-8")
+    if old_text not in current:
+        raise ValueError("old_text not found in file")
+
+    # Snapshot diagnostics before the edit so the hook can diff against the
+    # post-edit state. The hook itself handles "LSP off" / "no route" cases.
+    before = diagnostics_hook(str(resolved), None) if diagnostics_hook else None
+
+    updated = current.replace(old_text, new_text, 1)
+    resolved.write_text(updated, encoding="utf-8")
+    relative = resolved.relative_to(workspace.resolve(strict=False))
+    result = f"Edited {relative.as_posix()}"
+
+    if diagnostics_hook is not None:
+        appendix = diagnostics_hook(str(resolved), before)
+        if appendix:
+            result = f"{result}{appendix}"
+    return result