dscli-agent 0.1.0__py3-none-any.whl

dscli/__init__.py

@@ -0,0 +1,3 @@
+"""dscli - a local coding agent for your terminal."""
+
+__version__ = "0.1.0"

dscli/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

dscli/agent.py

@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import json
+import logging
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable
+
+from .attachments import Attachment
+from .browser import ChatSession
+from .config import Config
+from .display import AgentDisplay, PlainDisplay
+from .prompts import (
+    build_followup_prompt,
+    build_initial_prompt,
+    build_protocol_repair,
+    build_tool_results_prompt,
+    build_wrapup_prompt,
+)
+from .protocol import ProtocolError, Step, extract_final_prefix, parse_step
+from .tools import ApprovalRequired, ToolResult, Toolbox, workspace_preview
+
+log = logging.getLogger("dscli")
+
+
+@dataclass
+class AgentOutcome:
+    final: str
+    changed: list[str] = field(default_factory=list)
+    turns: int = 0
+    limit_reached: bool = False
+    denied: bool = False
+
+
+class Agent:
+    def __init__(
+        self,
+        *,
+        session: ChatSession,
+        config: Config,
+        toolbox: Toolbox,
+        task: str,
+        workspace: Path,
+        attachments: list[Attachment],
+        verbose: bool = False,
+        quiet: bool = False,
+        followup: bool = False,
+        on_final_snapshot: Callable[[str], None] | None = None,
+        display: AgentDisplay | None = None,
+    ) -> None:
+        self.session = session
+        self.cfg = config
+        self.toolbox = toolbox
+        self.task = task
+        self.workspace = workspace
+        self.attachments = attachments
+        self.verbose = verbose
+        self.followup = followup
+        self.on_final_snapshot = on_final_snapshot
+        self.display = display or PlainDisplay(quiet=quiet)
+        self._signature_counts: dict[str, int] = {}
+        self._denied = False
+        self._streamed_final = False
+
+    def _send_and_wait(self, message: str, files: list[Path] | None = None) -> str:
+        if self.on_final_snapshot is None:
+            return self.session.send_and_wait(message, files=files)
+        last_final: str | None = None
+
+        def on_reply_snapshot(raw: str) -> None:
+            nonlocal last_final
+            final = extract_final_prefix(raw)
+            if final is not None and final != last_final:
+                last_final = final
+                if not self._streamed_final:
+                    self._streamed_final = True
+                    self.display.stream_started()
+                self.on_final_snapshot(final)
+
+        return self.session.send_and_wait(
+            message, files=files, on_reply_snapshot=on_reply_snapshot
+        )
+
+    def run(self) -> AgentOutcome:
+        if self.followup:
+            initial = build_followup_prompt(self.task)
+        else:
+            initial = build_initial_prompt(
+                task=self.task,
+                workspace=self.workspace,
+                attachments=self.attachments,
+                workspace_tree=workspace_preview(self.workspace),
+                allow_shell=self.cfg.allow_shell,
+                allow_outside=self.cfg.allow_outside,
+                max_steps=self.cfg.max_steps,
+            )
+        if len(initial) > 80000:
+            raise ValueError(
+                "The prompt is too large. Attach long material as a file instead of "
+                "pasting it into the task."
+            )
+
+        attachment_paths = [a.path for a in self.attachments]
+        message = initial
+        files = attachment_paths if attachment_paths else None
+        turn = 0
+        protocol_failures = 0
+        last_reply = ""
+
+        while True:
+            turn += 1
+            self.display.turn_started(
+                turn, self.cfg.max_steps, len(files) if files else 0
+            )
+            try:
+                last_reply = self._send_and_wait(message, files=files)
+            finally:
+                files = None
+
+            if self.verbose and last_reply:
+                self.display.ensure_line_break()
+                log.debug("Raw reply (%d chars):\n%s", len(last_reply), last_reply)
+
+            try:
+                step = parse_step(last_reply)
+            except ProtocolError as exc:
+                protocol_failures += 1
+                self.session.save_last_response(last_reply, "protocol-error")
+                if protocol_failures > self.cfg.max_protocol_retries:
+                    raise ProtocolError(
+                        f"{exc} The raw reply was saved to the dscli debug directory.",
+                        last_reply,
+                    ) from exc
+                self.display.protocol_error(str(exc))
+                if turn >= self.cfg.max_steps:
+                    return self._wrap_up(turn, last_reply or str(exc))
+                message = build_protocol_repair(
+                    str(exc), task=self.task, step=turn, max_steps=self.cfg.max_steps
+                )
+                continue
+
+            if step.final is not None and not step.tool_calls:
+                return self._finish(step, turn)
+
+            if step.thought and self.verbose:
+                log.debug("thought: %s", step.thought)
+            if self.verbose:
+                self.display.thought(step.thought)
+
+            if not step.tool_calls:
+                # Should have been caught by the parser; treat it as a protocol miss.
+                protocol_failures += 1
+                if protocol_failures > self.cfg.max_protocol_retries:
+                    raise ProtocolError(
+                        "The model returned an envelope with no tool calls and no final answer.",
+                        last_reply,
+                    )
+                if turn >= self.cfg.max_steps:
+                    return self._wrap_up(turn, last_reply)
+                message = build_protocol_repair(
+                    "The envelope had neither tool_calls nor final.",
+                    task=self.task,
+                    step=turn,
+                    max_steps=self.cfg.max_steps,
+                )
+                continue
+
+            if turn >= self.cfg.max_steps:
+                self.display.budget_exhausted()
+                return self._wrap_up(turn, last_reply)
+
+            calls = step.tool_calls[: self.cfg.max_tool_calls]
+            results: list[ToolResult] = []
+            for call in calls:
+                self.display.tool_started(call)
+                started = time.monotonic()
+                result = self.toolbox.execute(call)
+                elapsed = time.monotonic() - started
+                results.append(result)
+                self.display.tool_finished(result, elapsed)
+                if "denied" in (result.output or "").lower():
+                    self._denied = True
+
+            if len(step.tool_calls) > len(calls):
+                skipped = len(step.tool_calls) - len(calls)
+                results.append(
+                    ToolResult(
+                        name="harness",
+                        arguments={},
+                        ok=False,
+                        output=(
+                            f"{skipped} additional tool calls were not executed because the "
+                            f"per-turn limit is {self.cfg.max_tool_calls}."
+                        ),
+                    )
+                )
+
+            notice_parts: list[str] = []
+            for result in results:
+                signature = result.name + ":" + json.dumps(result.arguments, sort_keys=True, ensure_ascii=False)
+                if not result.ok:
+                    self._signature_counts[signature] = self._signature_counts.get(signature, 0) + 1
+                    if self._signature_counts[signature] >= 2:
+                        notice_parts.append(
+                            "A tool call has now failed twice with the same arguments. Do not "
+                            "repeat it; change strategy or finish and explain the blocker."
+                        )
+                else:
+                    self._signature_counts[signature] = self._signature_counts.get(signature, 0) + 1
+                    if self._signature_counts[signature] >= 3:
+                        notice_parts.append(
+                            "You have repeated the same successful call three times. Use the "
+                            "result you already have and move on."
+                        )
+            if self._denied:
+                notice_parts.append(
+                    "The user denied at least one action. Do not try to bypass the denial."
+                )
+            notice = "\n".join(dict.fromkeys(notice_parts)) or None
+
+            message = build_tool_results_prompt(
+                task=self.task,
+                workspace=self.workspace,
+                results=results,
+                step=turn,
+                max_steps=self.cfg.max_steps,
+                changed=self.toolbox.changed_files,
+                allow_shell=self.cfg.allow_shell,
+                per_result_chars=self.cfg.max_tool_output_chars,
+                total_chars=self.cfg.max_turn_output_chars,
+                notice=notice,
+            )
+
+    def _finish(self, step: Step, turn: int) -> AgentOutcome:
+        final = (step.final or "").strip()
+        if not final:
+            final = "Done."
+        self.display.finished(
+            self.toolbox.changed_files,
+            turn,
+            show_status=not self._streamed_final,
+        )
+        return AgentOutcome(
+            final=final,
+            changed=self.toolbox.changed_files,
+            turns=turn,
+            denied=self._denied,
+        )
+
+    def _wrap_up(self, turn: int, last_reply: str) -> AgentOutcome:
+        prompt = build_wrapup_prompt(
+            task=self.task,
+            workspace=self.workspace,
+            changed=self.toolbox.changed_files,
+            step=turn,
+        )
+        self.display.wrapup_started()
+        reply = self._send_and_wait(prompt)
+        try:
+            step = parse_step(reply)
+        except ProtocolError:
+            self.session.save_last_response(reply, "wrapup-unparsed")
+            self._progress(ui.warn, "could not parse the wrap-up reply; showing raw text")
+            return AgentOutcome(
+                final=reply.strip() or "Stopped: the model-turn budget was exhausted.",
+                changed=self.toolbox.changed_files,
+                turns=turn,
+                limit_reached=True,
+                denied=self._denied,
+            )
+        if step.final is not None:
+            final = (step.final or "").strip() or "Stopped: the model-turn budget was exhausted."
+        else:
+            self.session.save_last_response(reply, "wrapup-with-tools")
+            final = reply.strip() or "Stopped: the model-turn budget was exhausted."
+        return AgentOutcome(
+            final=final,
+            changed=self.toolbox.changed_files,
+            turns=turn,
+            limit_reached=True,
+            denied=self._denied,
+        )
+
+
+def run_agent(
+    *,
+    session: ChatSession,
+    config: Config,
+    toolbox: Toolbox,
+    task: str,
+    workspace: Path,
+    attachments: list[Attachment],
+    verbose: bool = False,
+    quiet: bool = False,
+    followup: bool = False,
+    on_final_snapshot: Callable[[str], None] | None = None,
+    display: AgentDisplay | None = None,
+) -> AgentOutcome:
+    return Agent(
+        session=session,
+        config=config,
+        toolbox=toolbox,
+        task=task,
+        workspace=workspace,
+        attachments=attachments,
+        verbose=verbose,
+        quiet=quiet,
+        followup=followup,
+        on_final_snapshot=on_final_snapshot,
+        display=display,
+    ).run()

dscli/attachments.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import glob
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class AttachmentError(ValueError):
+    pass
+
+
+@dataclass
+class Attachment:
+    path: Path
+    size: int
+    inside_workspace: bool
+    kind: str
+
+    @property
+    def name(self) -> str:
+        return self.path.name
+
+    def display_path(self, root: Path) -> str:
+        try:
+            return self.path.relative_to(root).as_posix()
+        except ValueError:
+            return str(self.path)
+
+    @property
+    def size_human(self) -> str:
+        size = float(self.size)
+        for unit in ("B", "KB", "MB", "GB"):
+            if size < 1024 or unit == "GB":
+                return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
+            size /= 1024
+        return f"{size:.1f} GB"
+
+
+def _kind(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix in {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg", ".ico", ".tif", ".tiff"}:
+        return "image"
+    try:
+        with path.open("rb") as fh:
+            head = fh.read(8192)
+    except OSError:
+        return "unknown"
+    if b"\x00" in head:
+        return "binary"
+    return "text"
+
+
+def collect_attachments(
+    raw_paths: list[str],
+    workspace: Path,
+    *,
+    max_count: int = 20,
+    max_mb: int = 50,
+) -> list[Attachment]:
+    if not raw_paths:
+        return []
+
+    expanded: list[Path] = []
+    for raw in raw_paths:
+        text = os.path.expanduser(str(raw).strip())
+        if not text:
+            continue
+        if any(ch in text for ch in "*?["):
+            matches = [Path(p) for p in glob.glob(text, recursive=True)]
+            if not matches:
+                raise AttachmentError(f"No files matched: {raw}")
+            expanded.extend(matches)
+        else:
+            expanded.append(Path(text))
+
+    seen: set[str] = set()
+    result: list[Attachment] = []
+    for path in expanded:
+        try:
+            resolved = path.resolve(strict=True)
+        except FileNotFoundError:
+            raise AttachmentError(f"File not found: {path}") from None
+        except OSError as exc:
+            raise AttachmentError(f"Cannot read {path}: {exc}") from None
+        if resolved.is_dir():
+            raise AttachmentError(
+                f"{path} is a directory. Pass individual files (globs are supported)."
+            )
+        if not resolved.is_file():
+            raise AttachmentError(f"Not a regular file: {path}")
+        key = str(resolved).casefold() if os.name == "nt" else str(resolved)
+        if key in seen:
+            continue
+        seen.add(key)
+        size = resolved.stat().st_size
+        if size > max_mb * 1024 * 1024:
+            raise AttachmentError(
+                f"{path} is {size / (1024 * 1024):.1f} MB; the limit is {max_mb} MB."
+            )
+        try:
+            inside = resolved.is_relative_to(workspace.resolve())
+        except ValueError:
+            inside = False
+        result.append(Attachment(path=resolved, size=size, inside_workspace=inside, kind=_kind(resolved)))
+        if len(result) > max_count:
+            raise AttachmentError(
+                f"Too many attachments ({len(result)}). The limit is {max_count}."
+            )
+    return result
+
+
+def format_manifest(attachments: list[Attachment], root: Path) -> str:
+    if not attachments:
+        return "(no files were attached to this chat)"
+    lines = []
+    for att in attachments:
+        note = "" if att.inside_workspace else " [outside workspace: attached read-only; local tools cannot edit it]"
+        if att.kind != "text":
+            note += f" [{att.kind}: use the attachment itself]"
+        lines.append(f"- {att.display_path(root)} ({att.size_human}){note}")
+    return "\n".join(lines)