editbuffer 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

editbuffer/history.py

@@ -1,5 +1,14 @@
+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
 
@@ -31,3 +40,219 @@ class EditHistory:
 
     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/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.dist-info → editbuffer-0.2.3.dist-info}/METADATA

@@ -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.dist-info → editbuffer-0.2.3.dist-info}/RECORD

@@ -3,16 +3,16 @@ editbuffer/blocks.py,sha256=tqeGMLRqcUwSsaadxKxMnHnpVIIJocqFbV3lKRTPsIw,1376
 editbuffer/buffer.py,sha256=Wc1Ode1A37PIILPW4I0aQQk-8ebBImmXgAPwiCaPMrM,5623
 editbuffer/cli.py,sha256=pv7Lhrcxmztx6tlQSYdUswCcoTg7MSFbPkka1uoCKYs,4533
 editbuffer/errors.py,sha256=gQ33Uwqo_PKfv0gGzz9fAWfgMez_44TkjbfoqTRM8gQ,831
-editbuffer/history.py,sha256=ADi-ssGTB4OpIX3pDs-YtWGXLDUshg55COoKmxpgWdI,754
-editbuffer/mcp_server.py,sha256=tFCp3iXeQ3L5DdQmknjVTAKydsmv3CA3zDQuO8_Q78c,11772
+editbuffer/history.py,sha256=f5gq_4pRRze5kzGRb3gDp-sgpA53fCKHtDbqiABklCM,8026
+editbuffer/mcp_server.py,sha256=cvOKecfC2grvsWmaWfD55q9551abeSrk_cd9V4_76ak,15289
 editbuffer/operations.py,sha256=l2bPEnKmwXZKXBSc1jZU4r0kkEY9mdky9fDDotoRUFA,2051
 editbuffer/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 editbuffer/resolver.py,sha256=94wOuBylreBN1ddro6NoHZ_dW2xTUh6Tctp_T1xKMfU,5402
 editbuffer/selection.py,sha256=1favs_qZyTXx51NFT9FG1xxwwyb7YCKr3KzVbVlRq2g,5597
 editbuffer/validators.py,sha256=Nj6nOgP6199yuLtYYl45ASbgQ2jQXvRPm1tsLQKaj9w,534
-editbuffer-0.2.2.dist-info/licenses/LICENSE,sha256=ctvjyyJh_lx1XsyH6NKaxtB-DqJJ4tWYsXEJ15uNaTc,1071
-editbuffer-0.2.2.dist-info/METADATA,sha256=wt3zOgCbgITVO1Jgf_jlK8TSLGZ2azA5wz6Y0ytVfmw,6609
-editbuffer-0.2.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-editbuffer-0.2.2.dist-info/entry_points.txt,sha256=cL9-TdYS4juRT-WIvNlcuo9hdxojHMVDyo0MlafDVfA,95
-editbuffer-0.2.2.dist-info/top_level.txt,sha256=898lOqlpIlnmCPUHF0K7C4E5-PWrmWLWy4YHzYAsMsU,11
-editbuffer-0.2.2.dist-info/RECORD,,
+editbuffer-0.2.3.dist-info/licenses/LICENSE,sha256=ctvjyyJh_lx1XsyH6NKaxtB-DqJJ4tWYsXEJ15uNaTc,1071
+editbuffer-0.2.3.dist-info/METADATA,sha256=5b4uyeSxT_3D83-iYV_O3z_rvm_h3Mi_DzfMjBAaUsY,6560
+editbuffer-0.2.3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+editbuffer-0.2.3.dist-info/entry_points.txt,sha256=cL9-TdYS4juRT-WIvNlcuo9hdxojHMVDyo0MlafDVfA,95
+editbuffer-0.2.3.dist-info/top_level.txt,sha256=898lOqlpIlnmCPUHF0K7C4E5-PWrmWLWy4YHzYAsMsU,11
+editbuffer-0.2.3.dist-info/RECORD,,

{editbuffer-0.2.2.dist-info → editbuffer-0.2.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any