editbuffer 0.2.2__tar.gz → 0.2.3__tar.gz

{editbuffer-0.2.2/src/editbuffer.egg-info → editbuffer-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: editbuffer
-Version: 0.2.2
+Version: 0.2.3
 Summary: Selection-based mutable output buffer for LLM tools
 Author: averagedigital
 License-Expression: MIT
@@ -219,7 +219,6 @@ Claude Desktop and generic MCP client examples are in
 
 The server exposes:
 
-- `buffer_create`
 - `buffer_append`
 - `buffer_list`
 - `buffer_view`
@@ -231,8 +230,8 @@ The server exposes:
 - `buffer_history`
 - `buffer_rollback`
 - `buffer_commit`
-- `command_history`
-- `command_select`
+- `tool_history`
+- `tool_select`
 
 Buffers are in-memory and live for the MCP server process. The MCP layer calls
 the same core API and does not implement separate edit semantics.
@@ -249,10 +248,10 @@ Use the first-class selection tools for normal agent use:
 
 `buffer_edit` remains available for raw JSON operations.
 
-`buffer_commit` remembers non-empty committed output as a reusable command.
-`command_history` returns the last 10 commands, newest first. `command_select`
-creates a new pending buffer from a previous command so the model can reuse it
-instead of regenerating it.
+MCP calls are recorded in SQLite-backed history. `tool_history` returns recent
+calls, newest first. `tool_select` creates a pending buffer from selectable
+content in a previous call so the model can repair it instead of regenerating
+it.
 
 ## Examples
 

{editbuffer-0.2.2 → editbuffer-0.2.3}/README.md

@@ -201,7 +201,6 @@ Claude Desktop and generic MCP client examples are in
 
 The server exposes:
 
-- `buffer_create`
 - `buffer_append`
 - `buffer_list`
 - `buffer_view`
@@ -213,8 +212,8 @@ The server exposes:
 - `buffer_history`
 - `buffer_rollback`
 - `buffer_commit`
-- `command_history`
-- `command_select`
+- `tool_history`
+- `tool_select`
 
 Buffers are in-memory and live for the MCP server process. The MCP layer calls
 the same core API and does not implement separate edit semantics.
@@ -231,10 +230,10 @@ Use the first-class selection tools for normal agent use:
 
 `buffer_edit` remains available for raw JSON operations.
 
-`buffer_commit` remembers non-empty committed output as a reusable command.
-`command_history` returns the last 10 commands, newest first. `command_select`
-creates a new pending buffer from a previous command so the model can reuse it
-instead of regenerating it.
+MCP calls are recorded in SQLite-backed history. `tool_history` returns recent
+calls, newest first. `tool_select` creates a pending buffer from selectable
+content in a previous call so the model can repair it instead of regenerating
+it.
 
 ## Examples
 

{editbuffer-0.2.2 → editbuffer-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "editbuffer"
-version = "0.2.2"
+version = "0.2.3"
 description = "Selection-based mutable output buffer for LLM tools"
 readme = "README.md"
 requires-python = ">=3.11"

editbuffer-0.2.3/src/editbuffer/history.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+from datetime import UTC, datetime, timedelta
+from dataclasses import dataclass
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+from .operations import EditOperation
+
+
+@dataclass(frozen=True, slots=True)
+class EditRecord:
+    operation: EditOperation
+    start: int
+    end: int
+    before: str
+    after: str
+    version_before: int
+    version_after: int
+    confidence: float = 1.0
+
+
+class EditHistory:
+    def __init__(self) -> None:
+        self._records: list[EditRecord] = []
+
+    def append(self, record: EditRecord) -> None:
+        self._records.append(record)
+
+    def __len__(self) -> int:
+        return len(self._records)
+
+    def __getitem__(self, index: int) -> EditRecord:
+        return self._records[index]
+
+    def __iter__(self) -> Iterator[EditRecord]:
+        return iter(self._records)
+
+
+SECRET_KEYS = ("api_key", "token", "secret", "password", "authorization")
+
+
+class ToolHistoryStore:
+    def __init__(
+        self,
+        path: str | Path | None = None,
+        *,
+        retention_days: int | None = None,
+        default_limit: int | None = None,
+    ) -> None:
+        self.path = Path(path) if path is not None else _default_history_path()
+        self.retention_days = (
+            retention_days
+            if retention_days is not None
+            else int(os.environ.get("EDITBUFFER_HISTORY_RETENTION_DAYS", "7"))
+        )
+        self.default_limit = (
+            default_limit
+            if default_limit is not None
+            else int(os.environ.get("EDITBUFFER_HISTORY_LIMIT", "10"))
+        )
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_db()
+        self.cleanup()
+
+    def record_tool_call(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any] | None = None,
+        *,
+        call_id: str | None = None,
+        result: Any = None,
+        status: str = "success",
+        error: str | None = None,
+        content: str | None = None,
+        command: str | None = None,
+        timestamp: datetime | None = None,
+    ) -> str:
+        self.cleanup()
+        identifier = call_id or f"call-{uuid4().hex}"
+        when = timestamp or datetime.now(UTC)
+        redacted_arguments = _redact(arguments or {})
+        redacted_result = _redact(result)
+        with self._connect() as db:
+            db.execute(
+                """
+                INSERT OR REPLACE INTO tool_calls (
+                    call_id, timestamp, tool_name, arguments_json, result_json,
+                    result_summary, status, error, content, command
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    identifier,
+                    when.isoformat(),
+                    tool_name,
+                    _json_dump(redacted_arguments),
+                    _json_dump(redacted_result),
+                    _summary(redacted_result),
+                    status,
+                    error,
+                    content,
+                    command,
+                ),
+            )
+        return identifier
+
+    def list_tool_calls(self, limit: int | None = None) -> list[dict[str, Any]]:
+        self.cleanup()
+        row_limit = self.default_limit if limit is None else limit
+        with self._connect() as db:
+            rows = db.execute(
+                """
+                SELECT call_id, timestamp, tool_name, arguments_json, result_json,
+                       result_summary, status, error, content, command
+                FROM tool_calls
+                ORDER BY timestamp DESC, rowid DESC
+                LIMIT ?
+                """,
+                (row_limit,),
+            ).fetchall()
+        return [_row(row) for row in rows]
+
+    def get_tool_call(self, call_id: str) -> dict[str, Any]:
+        self.cleanup()
+        with self._connect() as db:
+            row = db.execute(
+                """
+                SELECT call_id, timestamp, tool_name, arguments_json, result_json,
+                       result_summary, status, error, content, command
+                FROM tool_calls
+                WHERE call_id = ?
+                """,
+                (call_id,),
+            ).fetchone()
+        if row is None:
+            raise KeyError(f"unknown tool call: {call_id}")
+        return _row(row)
+
+    def command_history(self, limit: int | None = None) -> list[dict[str, str]]:
+        row_limit = self.default_limit if limit is None else limit
+        with self._connect() as db:
+            rows = db.execute(
+                """
+                SELECT call_id, command
+                FROM tool_calls
+                WHERE command IS NOT NULL AND command != ''
+                ORDER BY timestamp DESC, rowid DESC
+                LIMIT ?
+                """,
+                (row_limit,),
+            ).fetchall()
+        return [{"command_id": row[0], "command": row[1]} for row in rows]
+
+    def get_command(self, command_id: str) -> str:
+        with self._connect() as db:
+            row = db.execute(
+                """
+                SELECT command
+                FROM tool_calls
+                WHERE call_id = ? AND command IS NOT NULL AND command != ''
+                """,
+                (command_id,),
+            ).fetchone()
+        if row is None:
+            raise KeyError(f"unknown command: {command_id}")
+        return str(row[0])
+
+    def cleanup(self) -> None:
+        cutoff = datetime.now(UTC) - timedelta(days=self.retention_days)
+        with self._connect() as db:
+            db.execute("DELETE FROM tool_calls WHERE timestamp < ?", (cutoff.isoformat(),))
+
+    def _init_db(self) -> None:
+        with self._connect() as db:
+            db.execute(
+                """
+                CREATE TABLE IF NOT EXISTS tool_calls (
+                    call_id TEXT PRIMARY KEY,
+                    timestamp TEXT NOT NULL,
+                    tool_name TEXT NOT NULL,
+                    arguments_json TEXT NOT NULL,
+                    result_json TEXT,
+                    result_summary TEXT,
+                    status TEXT NOT NULL,
+                    error TEXT,
+                    content TEXT,
+                    command TEXT
+                )
+                """
+            )
+            db.execute(
+                "CREATE INDEX IF NOT EXISTS idx_tool_calls_timestamp ON tool_calls(timestamp)"
+            )
+
+    def _connect(self) -> sqlite3.Connection:
+        return sqlite3.connect(self.path)
+
+
+def _default_history_path() -> Path:
+    configured = os.environ.get("EDITBUFFER_HISTORY_DB")
+    if configured:
+        return Path(configured)
+    return Path.home() / ".editbuffer" / "history.sqlite3"
+
+
+def _redact(value: Any) -> Any:
+    if isinstance(value, dict):
+        redacted: dict[str, Any] = {}
+        for key, item in value.items():
+            if any(secret in str(key).lower() for secret in SECRET_KEYS):
+                redacted[key] = "[REDACTED]"
+            else:
+                redacted[key] = _redact(item)
+        return redacted
+    if isinstance(value, list):
+        return [_redact(item) for item in value]
+    return value
+
+
+def _json_dump(value: Any) -> str | None:
+    if value is None:
+        return None
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, default=str)
+
+
+def _json_load(value: str | None) -> Any:
+    if value is None:
+        return None
+    return json.loads(value)
+
+
+def _summary(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = _json_dump(value)
+    if text is None:
+        return None
+    return text[:500]
+
+
+def _row(row: tuple[Any, ...]) -> dict[str, Any]:
+    return {
+        "call_id": row[0],
+        "timestamp": row[1],
+        "tool_name": row[2],
+        "arguments": _json_load(row[3]),
+        "result": _json_load(row[4]),
+        "result_summary": row[5],
+        "status": row[6],
+        "error": row[7],
+        "content": row[8],
+        "command": row[9],
+    }

{editbuffer-0.2.2 → editbuffer-0.2.3}/src/editbuffer/mcp_server.py

@@ -13,14 +13,14 @@ from .errors import (
     StaleVersionError,
     TargetNotFoundError,
 )
-from .history import EditRecord
+from .history import EditRecord, ToolHistoryStore
 
 
 class BufferRegistry:
-    def __init__(self) -> None:
+    def __init__(self, history_store: ToolHistoryStore | None = None) -> None:
         self._buffers: dict[str, EditBuffer] = {}
-        self._commands: list[dict[str, Any]] = []
-        self._next_command_number = 1
+        self._history_store = history_store or ToolHistoryStore()
+        self._next_command_number = self._initial_command_number()
 
     def create(
         self,
@@ -67,7 +67,7 @@ class BufferRegistry:
         return self._state(buffer_id, buffer)
 
     def command_history(self) -> list[dict[str, Any]]:
-        return list(self._commands)
+        return self._history_store.command_history()
 
     def current_version(self, buffer_id: str | None) -> int | None:
         if buffer_id is None:
@@ -81,10 +81,41 @@ class BufferRegistry:
         *,
         buffer_id: str | None = None,
     ) -> dict[str, Any]:
-        for item in self._commands:
-            if item["command_id"] == command_id:
-                return self.create(item["command"], buffer_id=buffer_id)
-        raise KeyError(f"unknown command: {command_id}")
+        return self.create(self._history_store.get_command(command_id), buffer_id=buffer_id)
+
+    def tool_history(self, limit: int | None = None) -> list[dict[str, Any]]:
+        return self._history_store.list_tool_calls(limit)
+
+    def record_tool_call(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any] | None = None,
+        *,
+        result: Any = None,
+        status: str = "success",
+        error: str | None = None,
+    ) -> str:
+        return self._history_store.record_tool_call(
+            tool_name,
+            arguments,
+            result=result,
+            status=status,
+            error=error,
+            content=_content_from(tool_name, arguments or {}, result),
+            command=(arguments or {}).get("command"),
+        )
+
+    def select_tool_call(
+        self,
+        call_id: str,
+        *,
+        buffer_id: str | None = None,
+    ) -> dict[str, Any]:
+        item = self._history_store.get_tool_call(call_id)
+        content = item.get("command") or item.get("content")
+        if not isinstance(content, str) or not content:
+            raise KeyError(f"tool call has no selectable content: {call_id}")
+        return self.create(content, buffer_id=buffer_id)
 
     def _get(self, buffer_id: str) -> EditBuffer:
         try:
@@ -104,15 +135,23 @@ class BufferRegistry:
     def _remember_command(self, command: str) -> None:
         if not command.strip():
             return
-        self._commands.insert(
-            0,
-            {
-                "command_id": f"cmd-{self._next_command_number}",
-                "command": command,
-            },
+        self._history_store.record_tool_call(
+            "command",
+            {"command": command},
+            call_id=f"cmd-{self._next_command_number}",
+            result={"command": command},
+            content=command,
+            command=command,
         )
         self._next_command_number += 1
-        del self._commands[10:]
+
+    def _initial_command_number(self) -> int:
+        numbers: list[int] = []
+        for item in self._history_store.command_history(limit=1000):
+            command_id = item["command_id"]
+            if command_id.startswith("cmd-") and command_id[4:].isdigit():
+                numbers.append(int(command_id[4:]))
+        return max(numbers, default=0) + 1
 
 
 def _record(record: EditRecord) -> dict[str, Any]:
@@ -148,27 +187,23 @@ def create_server() -> Any:
         json_response=True,
     )
 
-    @server.tool()
-    def buffer_create(
-        content: str = "",
-        buffer_id: str | None = None,
-    ) -> dict[str, Any]:
-        """Create an in-memory pending output buffer."""
-        return _tool_result(
-            lambda: registry.create(content, buffer_id=buffer_id),
-            registry,
-            buffer_id=buffer_id,
-        )
-
     @server.tool()
     def buffer_list() -> list[dict[str, Any]]:
         """List active pending output buffers."""
-        return registry.list_buffers()
+        result = registry.list_buffers()
+        registry.record_tool_call("buffer_list", {}, result=result)
+        return result
 
     @server.tool()
     def buffer_view(buffer_id: str) -> dict[str, Any]:
         """View current content, version, snapshots, and commit state."""
-        return _tool_result(lambda: registry.view(buffer_id), registry, buffer_id=buffer_id)
+        return _tool_result(
+            lambda: registry.view(buffer_id),
+            registry,
+            tool_name="buffer_view",
+            arguments={"buffer_id": buffer_id},
+            buffer_id=buffer_id,
+        )
 
     @server.tool()
     def buffer_edit(
@@ -185,6 +220,8 @@ def create_server() -> Any:
         return _tool_result(
             lambda: registry.edit(buffer_id, operation),
             registry,
+            tool_name="buffer_edit",
+            arguments={"buffer_id": buffer_id, "operation": operation},
             buffer_id=buffer_id,
         )
 
@@ -194,6 +231,8 @@ def create_server() -> Any:
         return _tool_result(
             lambda: registry.edit(buffer_id, {"op": "append", "text": text}),
             registry,
+            tool_name="buffer_append",
+            arguments={"buffer_id": buffer_id, "text": text},
             buffer_id=buffer_id,
         )
 
@@ -230,6 +269,8 @@ def create_server() -> Any:
         return _tool_result(
             lambda: registry.edit(buffer_id, {"op": "delete", "target": target}),
             registry,
+            tool_name="buffer_delete",
+            arguments={"buffer_id": buffer_id, "target": target},
             buffer_id=buffer_id,
         )
 
@@ -239,6 +280,8 @@ def create_server() -> Any:
         return _tool_result(
             lambda: registry.history(buffer_id),
             registry,
+            tool_name="buffer_history",
+            arguments={"buffer_id": buffer_id},
             buffer_id=buffer_id,
         )
 
@@ -248,28 +291,40 @@ def create_server() -> Any:
         return _tool_result(
             lambda: registry.rollback(buffer_id, version),
             registry,
+            tool_name="buffer_rollback",
+            arguments={"buffer_id": buffer_id, "version": version},
             buffer_id=buffer_id,
         )
 
     @server.tool()
     def buffer_commit(buffer_id: str) -> dict[str, Any]:
         """Commit final output, close the buffer, and remember it as a reusable command."""
-        return _tool_result(lambda: registry.commit(buffer_id), registry, buffer_id=buffer_id)
+        return _tool_result(
+            lambda: registry.commit(buffer_id),
+            registry,
+            tool_name="buffer_commit",
+            arguments={"buffer_id": buffer_id},
+            buffer_id=buffer_id,
+        )
 
     @server.tool()
-    def command_history() -> list[dict[str, Any]]:
-        """Return up to 10 most recently committed commands, newest first."""
-        return registry.command_history()
+    def tool_history(limit: int = 10) -> list[dict[str, Any]]:
+        """Return recent SQLite-backed tool calls, newest first."""
+        result = registry.tool_history(limit)
+        registry.record_tool_call("tool_history", {"limit": limit}, result=result)
+        return result
 
     @server.tool()
-    def command_select(
-        command_id: str,
+    def tool_select(
+        call_id: str,
         buffer_id: str | None = None,
     ) -> dict[str, Any]:
-        """Create a new pending buffer from a previous command instead of regenerating it."""
+        """Create a pending buffer from selectable content in a previous tool call."""
         return _tool_result(
-            lambda: registry.select_command(command_id, buffer_id=buffer_id),
+            lambda: registry.select_tool_call(call_id, buffer_id=buffer_id),
             registry,
+            tool_name="tool_select",
+            arguments={"call_id": call_id, "buffer_id": buffer_id},
             buffer_id=buffer_id,
         )
 
@@ -286,6 +341,8 @@ def _selection_tool(
     return _tool_result(
         lambda: registry.edit(buffer_id, {"op": op, "target": target, "text": text}),
         registry,
+        tool_name=f"buffer_{op}",
+        arguments={"buffer_id": buffer_id, "target": target, "text": text},
         buffer_id=buffer_id,
     )
 
@@ -294,18 +351,44 @@ def _tool_result(
     call: Any,
     registry: BufferRegistry,
     *,
+    tool_name: str | None = None,
+    arguments: dict[str, Any] | None = None,
     buffer_id: str | None = None,
 ) -> Any:
     try:
-        return call()
+        result = call()
+        if tool_name is not None:
+            registry.record_tool_call(tool_name, arguments or {}, result=result)
+        return result
     except (EditBufferError, KeyError, ValueError) as error:
-        return {
+        result = {
             "ok": False,
             "error": _structured_error(
                 error,
                 current_version=registry.current_version(buffer_id),
             ),
         }
+        if tool_name is not None:
+            registry.record_tool_call(
+                tool_name,
+                arguments or {},
+                result=result,
+                status="failed",
+                error=_message(error),
+            )
+        return result
+
+
+def _content_from(tool_name: str, arguments: dict[str, Any], result: Any) -> str | None:
+    for key in ("command", "content", "text"):
+        value = arguments.get(key)
+        if isinstance(value, str) and value:
+            return value
+    if isinstance(result, dict):
+        value = result.get("content")
+        if isinstance(value, str) and tool_name in {"buffer_create", "buffer_view"}:
+            return value
+    return None
 
 
 def _structured_error(
@@ -344,6 +427,10 @@ def _error_type(error: Exception) -> str:
             return "unknown_buffer"
         if message.startswith("unknown command:"):
             return "unknown_command"
+        if message.startswith("unknown tool call:"):
+            return "unknown_tool_call"
+        if message.startswith("tool call has no selectable content:"):
+            return "unselectable_tool_call"
         return "not_found"
     if isinstance(error, ValueError):
         message = _message(error)

{editbuffer-0.2.2 → editbuffer-0.2.3/src/editbuffer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: editbuffer
-Version: 0.2.2
+Version: 0.2.3
 Summary: Selection-based mutable output buffer for LLM tools
 Author: averagedigital
 License-Expression: MIT
@@ -219,7 +219,6 @@ Claude Desktop and generic MCP client examples are in
 
 The server exposes:
 
-- `buffer_create`
 - `buffer_append`
 - `buffer_list`
 - `buffer_view`
@@ -231,8 +230,8 @@ The server exposes:
 - `buffer_history`
 - `buffer_rollback`
 - `buffer_commit`
-- `command_history`
-- `command_select`
+- `tool_history`
+- `tool_select`
 
 Buffers are in-memory and live for the MCP server process. The MCP layer calls
 the same core API and does not implement separate edit semantics.
@@ -249,10 +248,10 @@ Use the first-class selection tools for normal agent use:
 
 `buffer_edit` remains available for raw JSON operations.
 
-`buffer_commit` remembers non-empty committed output as a reusable command.
-`command_history` returns the last 10 commands, newest first. `command_select`
-creates a new pending buffer from a previous command so the model can reuse it
-instead of regenerating it.
+MCP calls are recorded in SQLite-backed history. `tool_history` returns recent
+calls, newest first. `tool_select` creates a pending buffer from selectable
+content in a previous call so the model can repair it instead of regenerating
+it.
 
 ## Examples
 

{editbuffer-0.2.2 → editbuffer-0.2.3}/src/editbuffer.egg-info/SOURCES.txt

@@ -20,6 +20,10 @@ src/editbuffer.egg-info/entry_points.txt
 src/editbuffer.egg-info/requires.txt
 src/editbuffer.egg-info/top_level.txt
 tests/test_cli.py
+tests/test_collect_harbor_results.py
 tests/test_editbuffer.py
 tests/test_mcp_server.py
-tests/test_mcp_stdio_eval.py
+tests/test_mcp_stdio_eval.py
+tests/test_metrics.py
+tests/test_parse_agent_trajectories.py
+tests/test_run_terminal_bench_ab.py