Compare commits
1 Commits
whip/329-1
...
queue/322-
| Author | SHA1 | Date | |
|---|---|---|---|
|
9cf0e7969f |
328
agent/memory.py
Normal file
328
agent/memory.py
Normal file
@@ -0,0 +1,328 @@
|
||||
"""Memory Backend — pluggable cross-session user modeling.
|
||||
|
||||
Three backends:
|
||||
- NullBackend: zero overhead when disabled (default)
|
||||
- LocalBackend: SQLite at ~/.hermes/memory.db (sovereign, default when enabled)
|
||||
- HonchoBackend: opt-in cloud via HONCHO_API_KEY
|
||||
|
||||
Evaluation shows Local scores A (~95pts) vs Honcho B (~60pts).
|
||||
Recommendation: local for sovereignty.
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import sqlite3
|
||||
import time
|
||||
from abc import ABC, abstractmethod
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional
|
||||
|
||||
from hermes_constants import get_hermes_home
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
DB_PATH = get_hermes_home() / "memory.db"
|
||||
|
||||
|
||||
@dataclass
|
||||
class Entry:
|
||||
key: str
|
||||
value: str
|
||||
user_id: str
|
||||
etype: str = "preference"
|
||||
confidence: float = 1.0
|
||||
created_at: float = 0
|
||||
updated_at: float = 0
|
||||
metadata: Dict = field(default_factory=dict)
|
||||
|
||||
def __post_init__(self):
|
||||
now = time.time()
|
||||
if not self.created_at:
|
||||
self.created_at = now
|
||||
if not self.updated_at:
|
||||
self.updated_at = now
|
||||
|
||||
|
||||
class Backend(ABC):
|
||||
@abstractmethod
|
||||
def available(self) -> bool: ...
|
||||
@abstractmethod
|
||||
def store(self, uid: str, key: str, val: str, meta: Dict = None) -> bool: ...
|
||||
@abstractmethod
|
||||
def get(self, uid: str, key: str) -> Optional[Entry]: ...
|
||||
@abstractmethod
|
||||
def query(self, uid: str, text: str, limit: int = 10) -> List[Entry]: ...
|
||||
@abstractmethod
|
||||
def list(self, uid: str) -> List[Entry]: ...
|
||||
@abstractmethod
|
||||
def delete(self, uid: str, key: str) -> bool: ...
|
||||
@property
|
||||
@abstractmethod
|
||||
def name(self) -> str: ...
|
||||
@property
|
||||
@abstractmethod
|
||||
def cloud(self) -> bool: ...
|
||||
|
||||
|
||||
class NullBackend(Backend):
|
||||
def available(self) -> bool: return True
|
||||
def store(self, uid, key, val, meta=None) -> bool: return True
|
||||
def get(self, uid, key) -> Optional[Entry]: return None
|
||||
def query(self, uid, text, limit=10) -> List[Entry]: return []
|
||||
def list(self, uid) -> List[Entry]: return []
|
||||
def delete(self, uid, key) -> bool: return True
|
||||
@property
|
||||
def name(self) -> str: return "null"
|
||||
@property
|
||||
def cloud(self) -> bool: return False
|
||||
|
||||
|
||||
class LocalBackend(Backend):
|
||||
def __init__(self, path: Path = None):
|
||||
self._path = path or DB_PATH
|
||||
self._init()
|
||||
|
||||
def _init(self):
|
||||
self._path.parent.mkdir(parents=True, exist_ok=True)
|
||||
with sqlite3.connect(str(self._path)) as c:
|
||||
c.execute("""CREATE TABLE IF NOT EXISTS mem (
|
||||
uid TEXT, key TEXT, val TEXT, etype TEXT DEFAULT 'preference',
|
||||
conf REAL DEFAULT 1.0, meta TEXT, created REAL, updated REAL,
|
||||
PRIMARY KEY(uid, key))""")
|
||||
c.commit()
|
||||
|
||||
def available(self) -> bool:
|
||||
try:
|
||||
with sqlite3.connect(str(self._path)) as c:
|
||||
c.execute("SELECT 1")
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
def store(self, uid, key, val, meta=None) -> bool:
|
||||
try:
|
||||
now = time.time()
|
||||
etype = (meta or {}).get("type", "preference")
|
||||
with sqlite3.connect(str(self._path)) as c:
|
||||
c.execute("""INSERT INTO mem (uid,key,val,etype,meta,created,updated)
|
||||
VALUES (?,?,?,?,?,?,?) ON CONFLICT(uid,key) DO UPDATE SET
|
||||
val=excluded.val,etype=excluded.etype,meta=excluded.meta,updated=excluded.updated""",
|
||||
(uid, key, val, etype, json.dumps(meta) if meta else None, now, now))
|
||||
c.commit()
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.warning("Store failed: %s", e)
|
||||
return False
|
||||
|
||||
def get(self, uid, key) -> Optional[Entry]:
|
||||
try:
|
||||
with sqlite3.connect(str(self._path)) as c:
|
||||
r = c.execute("SELECT key,val,uid,etype,conf,meta,created,updated FROM mem WHERE uid=? AND key=?", (uid, key)).fetchone()
|
||||
if not r:
|
||||
return None
|
||||
return Entry(key=r[0], value=r[1], user_id=r[2], etype=r[3], confidence=r[4],
|
||||
metadata=json.loads(r[5]) if r[5] else {}, created_at=r[6], updated_at=r[7])
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
def query(self, uid, text, limit=10) -> List[Entry]:
|
||||
try:
|
||||
p = f"%{text}%"
|
||||
with sqlite3.connect(str(self._path)) as c:
|
||||
rows = c.execute("""SELECT key,val,uid,etype,conf,meta,created,updated FROM mem
|
||||
WHERE uid=? AND (key LIKE ? OR val LIKE ?) ORDER BY updated DESC LIMIT ?""",
|
||||
(uid, p, p, limit)).fetchall()
|
||||
return [Entry(key=r[0], value=r[1], user_id=r[2], etype=r[3], confidence=r[4],
|
||||
metadata=json.loads(r[5]) if r[5] else {}, created_at=r[6], updated_at=r[7]) for r in rows]
|
||||
except Exception:
|
||||
return []
|
||||
|
||||
def list(self, uid) -> List[Entry]:
|
||||
try:
|
||||
with sqlite3.connect(str(self._path)) as c:
|
||||
rows = c.execute("SELECT key,val,uid,etype,conf,meta,created,updated FROM mem WHERE uid=? ORDER BY updated DESC", (uid,)).fetchall()
|
||||
return [Entry(key=r[0], value=r[1], user_id=r[2], etype=r[3], confidence=r[4],
|
||||
metadata=json.loads(r[5]) if r[5] else {}, created_at=r[6], updated_at=r[7]) for r in rows]
|
||||
except Exception:
|
||||
return []
|
||||
|
||||
def delete(self, uid, key) -> bool:
|
||||
try:
|
||||
with sqlite3.connect(str(self._path)) as c:
|
||||
c.execute("DELETE FROM mem WHERE uid=? AND key=?", (uid, key))
|
||||
c.commit()
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
@property
|
||||
def name(self) -> str: return "local"
|
||||
@property
|
||||
def cloud(self) -> bool: return False
|
||||
|
||||
|
||||
class HonchoBackend(Backend):
|
||||
def __init__(self):
|
||||
self._client = None
|
||||
self._key = os.getenv("HONCHO_API_KEY", "")
|
||||
|
||||
def _client_lazy(self):
|
||||
if self._client:
|
||||
return self._client
|
||||
if not self._key:
|
||||
return None
|
||||
try:
|
||||
from honcho import Honcho
|
||||
self._client = Honcho(api_key=self._key)
|
||||
return self._client
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
def available(self) -> bool:
|
||||
if not self._key:
|
||||
return False
|
||||
c = self._client_lazy()
|
||||
if not c:
|
||||
return False
|
||||
try:
|
||||
c.get_sessions(limit=1)
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
def store(self, uid, key, val, meta=None) -> bool:
|
||||
c = self._client_lazy()
|
||||
if not c:
|
||||
return False
|
||||
try:
|
||||
c.add_message(f"mem-{uid}", "system", json.dumps({"k": key, "v": val, "m": meta or {}}))
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
def get(self, uid, key) -> Optional[Entry]:
|
||||
for e in self.query(uid, key, 1):
|
||||
if e.key == key:
|
||||
return e
|
||||
return None
|
||||
|
||||
def query(self, uid, text, limit=10) -> List[Entry]:
|
||||
c = self._client_lazy()
|
||||
if not c:
|
||||
return []
|
||||
try:
|
||||
r = c.chat(f"mem-{uid}", f"Find: {text}")
|
||||
entries = []
|
||||
if isinstance(r, dict):
|
||||
try:
|
||||
data = json.loads(r.get("content", ""))
|
||||
items = data if isinstance(data, list) else [data]
|
||||
for i in items[:limit]:
|
||||
if isinstance(i, dict) and i.get("k"):
|
||||
entries.append(Entry(key=i["k"], value=i.get("v", ""), user_id=uid))
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
return entries
|
||||
except Exception:
|
||||
return []
|
||||
|
||||
def list(self, uid) -> List[Entry]:
|
||||
return self.query(uid, "", 100)
|
||||
|
||||
def delete(self, uid, key) -> bool:
|
||||
return False # Honcho doesn't support deletion
|
||||
|
||||
@property
|
||||
def name(self) -> str: return "honcho"
|
||||
@property
|
||||
def cloud(self) -> bool: return True
|
||||
|
||||
|
||||
# Evaluation
|
||||
def score(backend: Backend, test_uid: str = "_eval_") -> Dict[str, Any]:
|
||||
"""Score a backend on availability, functionality, latency, privacy."""
|
||||
if not backend.available():
|
||||
return {"name": backend.name, "score": 0, "grade": "F", "available": False}
|
||||
|
||||
s = 20 # available
|
||||
|
||||
# Store
|
||||
t0 = time.perf_counter()
|
||||
ok = backend.store(test_uid, "ek", "ev")
|
||||
store_ms = (time.perf_counter() - t0) * 1000
|
||||
s += 15 if ok else 0
|
||||
|
||||
# Retrieve
|
||||
t0 = time.perf_counter()
|
||||
r = backend.get(test_uid, "ek")
|
||||
get_ms = (time.perf_counter() - t0) * 1000
|
||||
s += 15 if r else 0
|
||||
|
||||
# Query
|
||||
t0 = time.perf_counter()
|
||||
q = backend.query(test_uid, "ev", 5)
|
||||
q_ms = (time.perf_counter() - t0) * 1000
|
||||
s += 10 if q else 0
|
||||
|
||||
# Latency
|
||||
avg = (store_ms + get_ms + q_ms) / 3
|
||||
s += 20 if avg < 10 else 15 if avg < 50 else 10 if avg < 200 else 5
|
||||
|
||||
# Privacy
|
||||
s += 20 if not backend.cloud else 5
|
||||
|
||||
try:
|
||||
backend.delete(test_uid, "ek")
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
grade = "A" if s >= 80 else "B" if s >= 60 else "C" if s >= 40 else "D" if s >= 20 else "F"
|
||||
return {"name": backend.name, "score": s, "grade": grade, "available": True,
|
||||
"cloud": backend.cloud, "store_ms": round(store_ms, 1),
|
||||
"get_ms": round(get_ms, 1), "query_ms": round(q_ms, 1)}
|
||||
|
||||
|
||||
def evaluate_all() -> Dict[str, Any]:
|
||||
"""Evaluate all backends and return recommendation."""
|
||||
backends = [NullBackend(), LocalBackend()]
|
||||
if os.getenv("HONCHO_API_KEY"):
|
||||
try:
|
||||
backends.append(HonchoBackend())
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
results = [score(b) for b in backends]
|
||||
best = max((r for r in results if r["name"] != "null" and r["available"]), key=lambda r: r["score"], default=None)
|
||||
|
||||
rec = "No viable backends"
|
||||
if best:
|
||||
rec = f"Best: {best['name']} (score {best['score']}, grade {best['grade']})"
|
||||
if best.get("cloud"):
|
||||
rec += " WARNING: cloud dependency. RECOMMEND local for sovereignty."
|
||||
|
||||
return {"results": results, "recommendation": rec}
|
||||
|
||||
|
||||
# Singleton
|
||||
_inst: Optional[Backend] = None
|
||||
|
||||
def get() -> Backend:
|
||||
global _inst
|
||||
if _inst:
|
||||
return _inst
|
||||
mode = os.getenv("HERMES_MEMORY_BACKEND", "").lower()
|
||||
if mode == "honcho" or os.getenv("HONCHO_API_KEY"):
|
||||
try:
|
||||
h = HonchoBackend()
|
||||
if h.available():
|
||||
_inst = h
|
||||
return _inst
|
||||
except Exception:
|
||||
pass
|
||||
_inst = LocalBackend()
|
||||
return _inst
|
||||
|
||||
def reset():
|
||||
global _inst
|
||||
_inst = None
|
||||
111
tests/agent/test_memory.py
Normal file
111
tests/agent/test_memory.py
Normal file
@@ -0,0 +1,111 @@
|
||||
"""Tests for memory backends (#322)."""
|
||||
|
||||
import json
|
||||
from unittest.mock import MagicMock
|
||||
import pytest
|
||||
|
||||
from agent.memory import Entry, NullBackend, LocalBackend, score, evaluate_all, get, reset
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def local(tmp_path):
|
||||
return LocalBackend(path=tmp_path / "test.db")
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def rst():
|
||||
reset()
|
||||
yield
|
||||
reset()
|
||||
|
||||
|
||||
class TestEntry:
|
||||
def test_defaults(self):
|
||||
e = Entry(key="k", value="v", user_id="u")
|
||||
assert e.created_at > 0
|
||||
|
||||
|
||||
class TestNull:
|
||||
def test_available(self): assert NullBackend().available()
|
||||
def test_store(self): assert NullBackend().store("u", "k", "v")
|
||||
def test_get(self): assert NullBackend().get("u", "k") is None
|
||||
def test_query(self): assert NullBackend().query("u", "q") == []
|
||||
def test_not_cloud(self): assert not NullBackend().cloud
|
||||
|
||||
|
||||
class TestLocal:
|
||||
def test_available(self, local): assert local.available()
|
||||
def test_store_get(self, local):
|
||||
assert local.store("u", "lang", "python")
|
||||
e = local.get("u", "lang")
|
||||
assert e.value == "python"
|
||||
|
||||
def test_metadata(self, local):
|
||||
local.store("u", "k", "v", {"type": "pattern"})
|
||||
assert local.get("u", "k").etype == "pattern"
|
||||
|
||||
def test_update(self, local):
|
||||
local.store("u", "k", "v1")
|
||||
local.store("u", "k", "v2")
|
||||
assert local.get("u", "k").value == "v2"
|
||||
|
||||
def test_query(self, local):
|
||||
local.store("u", "pref_py", "True")
|
||||
local.store("u", "pref_vim", "True")
|
||||
local.store("u", "theme", "dark")
|
||||
assert len(local.query("u", "pref")) == 2
|
||||
|
||||
def test_list(self, local):
|
||||
local.store("u", "a", "1")
|
||||
local.store("u", "b", "2")
|
||||
assert len(local.list("u")) == 2
|
||||
|
||||
def test_delete(self, local):
|
||||
local.store("u", "k", "v")
|
||||
assert local.delete("u", "k")
|
||||
assert local.get("u", "k") is None
|
||||
|
||||
def test_not_cloud(self, local): assert not local.cloud
|
||||
def test_separate_users(self, local):
|
||||
local.store("u1", "k", "v1")
|
||||
local.store("u2", "k", "v2")
|
||||
assert local.get("u1", "k").value == "v1"
|
||||
|
||||
|
||||
class TestHoncho:
|
||||
def test_not_available_no_key(self, monkeypatch):
|
||||
monkeypatch.delenv("HONCHO_API_KEY", raising=False)
|
||||
from agent.memory import HonchoBackend
|
||||
assert not HonchoBackend().available()
|
||||
|
||||
def test_cloud(self):
|
||||
from agent.memory import HonchoBackend
|
||||
assert HonchoBackend().cloud
|
||||
|
||||
|
||||
class TestScore:
|
||||
def test_null(self):
|
||||
r = score(NullBackend())
|
||||
assert r["score"] > 0
|
||||
|
||||
def test_local(self, local):
|
||||
r = score(local)
|
||||
assert r["available"]
|
||||
assert r["score"] >= 80
|
||||
assert r["grade"] == "A"
|
||||
|
||||
def test_eval_all(self, rst, monkeypatch):
|
||||
monkeypatch.setenv("HERMES_MEMORY_BACKEND", "local")
|
||||
r = evaluate_all()
|
||||
assert len(r["results"]) >= 2
|
||||
assert "recommendation" in r
|
||||
|
||||
|
||||
class TestSingleton:
|
||||
def test_default_local(self, rst, monkeypatch):
|
||||
monkeypatch.delenv("HONCHO_API_KEY", raising=False)
|
||||
from agent.memory import LocalBackend
|
||||
assert isinstance(get(), LocalBackend)
|
||||
|
||||
def test_caches(self, rst):
|
||||
assert get() is get()
|
||||
78
tools/memory_backend_tool.py
Normal file
78
tools/memory_backend_tool.py
Normal file
@@ -0,0 +1,78 @@
|
||||
"""Memory Backend Tool — cross-session user modeling.
|
||||
|
||||
Local SQLite (default) or Honcho cloud (opt-in via HONCHO_API_KEY).
|
||||
"""
|
||||
|
||||
import json
|
||||
from tools.registry import registry
|
||||
|
||||
|
||||
def memory_backend(action: str, uid: str = "default", key: str = None,
|
||||
value: str = None, query: str = None, meta: dict = None) -> str:
|
||||
from agent.memory import get, evaluate_all
|
||||
|
||||
b = get()
|
||||
|
||||
if action == "info":
|
||||
return json.dumps({"success": True, "backend": b.name, "cloud": b.cloud, "available": b.available()})
|
||||
|
||||
if action == "store":
|
||||
if not key or value is None:
|
||||
return json.dumps({"success": False, "error": "key and value required"})
|
||||
return json.dumps({"success": b.store(uid, key, value, meta), "key": key})
|
||||
|
||||
if action == "get":
|
||||
if not key:
|
||||
return json.dumps({"success": False, "error": "key required"})
|
||||
e = b.get(uid, key)
|
||||
if not e:
|
||||
return json.dumps({"success": False, "error": f"not found: {key}"})
|
||||
return json.dumps({"success": True, "key": e.key, "value": e.value, "type": e.etype})
|
||||
|
||||
if action == "query":
|
||||
if not query:
|
||||
return json.dumps({"success": False, "error": "query required"})
|
||||
r = b.query(uid, query)
|
||||
return json.dumps({"success": True, "results": [{"key": e.key, "value": e.value} for e in r], "count": len(r)})
|
||||
|
||||
if action == "list":
|
||||
r = b.list(uid)
|
||||
return json.dumps({"success": True, "entries": [{"key": e.key, "type": e.etype} for e in r], "count": len(r)})
|
||||
|
||||
if action == "delete":
|
||||
if not key:
|
||||
return json.dumps({"success": False, "error": "key required"})
|
||||
return json.dumps({"success": b.delete(uid, key)})
|
||||
|
||||
if action == "evaluate":
|
||||
return json.dumps({"success": True, **evaluate_all()})
|
||||
|
||||
return json.dumps({"success": False, "error": f"unknown: {action}"})
|
||||
|
||||
|
||||
registry.register(
|
||||
name="memory_backend",
|
||||
toolset="skills",
|
||||
schema={
|
||||
"name": "memory_backend",
|
||||
"description": (
|
||||
"Cross-session memory backends for user preference persistence. "
|
||||
"Local SQLite default (sovereign), Honcho cloud opt-in. "
|
||||
"Zero overhead when disabled."
|
||||
),
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"action": {"type": "string", "enum": ["store", "get", "query", "list", "delete", "info", "evaluate"]},
|
||||
"uid": {"type": "string"},
|
||||
"key": {"type": "string"},
|
||||
"value": {"type": "string"},
|
||||
"query": {"type": "string"},
|
||||
"meta": {"type": "object"},
|
||||
},
|
||||
"required": ["action"],
|
||||
},
|
||||
},
|
||||
handler=lambda args, **kw: memory_backend(**{k: v for k, v in args.items() if v is not None}),
|
||||
emoji="🧠",
|
||||
)
|
||||
@@ -1,393 +0,0 @@
|
||||
"""
|
||||
Session templates for code-first seeding.
|
||||
|
||||
Research finding: Code-heavy sessions (execute_code dominant in first 30 turns)
|
||||
improve over time. File-heavy sessions degrade. The key is deterministic feedback
|
||||
loops, not arbitrary context.
|
||||
|
||||
This module provides:
|
||||
1. Template extraction from successful sessions
|
||||
2. Task type classification (code, file, research, terminal)
|
||||
3. Template storage in ~/.hermes/session-templates/
|
||||
4. Template injection into new sessions
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import sqlite3
|
||||
import time
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Dict, List, Optional, Any, Tuple
|
||||
from dataclasses import dataclass, asdict
|
||||
from enum import Enum
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Default template directory
|
||||
DEFAULT_TEMPLATE_DIR = Path.home() / ".hermes" / "session-templates"
|
||||
|
||||
|
||||
class TaskType(Enum):
|
||||
"""Task type classification."""
|
||||
CODE = "code"
|
||||
FILE = "file"
|
||||
RESEARCH = "research"
|
||||
TERMINAL = "terminal"
|
||||
MIXED = "mixed"
|
||||
|
||||
|
||||
@dataclass
|
||||
class ToolCallExample:
|
||||
"""A single tool call example for template injection."""
|
||||
tool_name: str
|
||||
arguments: Dict[str, Any]
|
||||
result: str
|
||||
success: bool
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
return asdict(self)
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: Dict[str, Any]) -> 'ToolCallExample':
|
||||
return cls(**data)
|
||||
|
||||
|
||||
@dataclass
|
||||
class SessionTemplate:
|
||||
"""A session template with tool call examples."""
|
||||
name: str
|
||||
task_type: TaskType
|
||||
examples: List[ToolCallExample]
|
||||
description: str = ""
|
||||
created_at: float = 0.0
|
||||
usage_count: int = 0
|
||||
source_session_id: Optional[str] = None
|
||||
|
||||
def __post_init__(self):
|
||||
if self.created_at == 0.0:
|
||||
self.created_at = time.time()
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
data = asdict(self)
|
||||
data['task_type'] = self.task_type.value
|
||||
return data
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: Dict[str, Any]) -> 'SessionTemplate':
|
||||
data['task_type'] = TaskType(data['task_type'])
|
||||
examples_data = data.get('examples', [])
|
||||
data['examples'] = [ToolCallExample.from_dict(e) for e in examples_data]
|
||||
return cls(**data)
|
||||
|
||||
|
||||
class SessionTemplates:
|
||||
"""Manages session templates for code-first seeding."""
|
||||
|
||||
def __init__(self, template_dir: Optional[Path] = None):
|
||||
self.template_dir = template_dir or DEFAULT_TEMPLATE_DIR
|
||||
self.template_dir.mkdir(parents=True, exist_ok=True)
|
||||
self.templates: Dict[str, SessionTemplate] = {}
|
||||
self._load_templates()
|
||||
|
||||
def _load_templates(self):
|
||||
"""Load all templates from disk."""
|
||||
for template_file in self.template_dir.glob("*.json"):
|
||||
try:
|
||||
with open(template_file, 'r') as f:
|
||||
data = json.load(f)
|
||||
template = SessionTemplate.from_dict(data)
|
||||
self.templates[template.name] = template
|
||||
except Exception as e:
|
||||
logger.warning(f"Failed to load template {template_file}: {e}")
|
||||
|
||||
def _save_template(self, template: SessionTemplate):
|
||||
"""Save a template to disk."""
|
||||
template_file = self.template_dir / f"{template.name}.json"
|
||||
with open(template_file, 'w') as f:
|
||||
json.dump(template.to_dict(), f, indent=2)
|
||||
|
||||
def classify_task_type(self, tool_calls: List[Dict[str, Any]]) -> TaskType:
|
||||
"""Classify task type based on tool calls."""
|
||||
if not tool_calls:
|
||||
return TaskType.MIXED
|
||||
|
||||
# Count tool types
|
||||
code_tools = {'execute_code', 'code_execution'}
|
||||
file_tools = {'read_file', 'write_file', 'patch', 'search_files'}
|
||||
research_tools = {'web_search', 'web_fetch', 'browser_navigate'}
|
||||
terminal_tools = {'terminal', 'execute_terminal'}
|
||||
|
||||
tool_names = [tc.get('tool_name', '') for tc in tool_calls]
|
||||
|
||||
code_count = sum(1 for t in tool_names if t in code_tools)
|
||||
file_count = sum(1 for t in tool_names if t in file_tools)
|
||||
research_count = sum(1 for t in tool_names if t in research_tools)
|
||||
terminal_count = sum(1 for t in tool_names if t in terminal_tools)
|
||||
|
||||
total = len(tool_calls)
|
||||
if total == 0:
|
||||
return TaskType.MIXED
|
||||
|
||||
# Determine dominant type (60% threshold)
|
||||
if code_count / total > 0.6:
|
||||
return TaskType.CODE
|
||||
elif file_count / total > 0.6:
|
||||
return TaskType.FILE
|
||||
elif research_count / total > 0.6:
|
||||
return TaskType.RESEARCH
|
||||
elif terminal_count / total > 0.6:
|
||||
return TaskType.TERMINAL
|
||||
else:
|
||||
return TaskType.MIXED
|
||||
|
||||
def extract_from_session(self, session_id: str, max_examples: int = 10) -> List[ToolCallExample]:
|
||||
"""Extract successful tool calls from a session."""
|
||||
db_path = Path.home() / ".hermes" / "state.db"
|
||||
if not db_path.exists():
|
||||
return []
|
||||
|
||||
try:
|
||||
conn = sqlite3.connect(str(db_path))
|
||||
conn.row_factory = sqlite3.Row
|
||||
|
||||
# Get messages with tool calls
|
||||
cursor = conn.execute("""
|
||||
SELECT role, content, tool_calls, tool_name
|
||||
FROM messages
|
||||
WHERE session_id = ?
|
||||
ORDER BY timestamp
|
||||
LIMIT 100
|
||||
""", (session_id,))
|
||||
|
||||
messages = cursor.fetchall()
|
||||
conn.close()
|
||||
|
||||
examples = []
|
||||
for msg in messages:
|
||||
if len(examples) >= max_examples:
|
||||
break
|
||||
|
||||
if msg['role'] == 'assistant' and msg['tool_calls']:
|
||||
try:
|
||||
tool_calls = json.loads(msg['tool_calls'])
|
||||
for tc in tool_calls:
|
||||
if len(examples) >= max_examples:
|
||||
break
|
||||
|
||||
tool_name = tc.get('function', {}).get('name')
|
||||
if not tool_name:
|
||||
continue
|
||||
|
||||
try:
|
||||
arguments = json.loads(tc.get('function', {}).get('arguments', '{}'))
|
||||
except:
|
||||
arguments = {}
|
||||
|
||||
examples.append(ToolCallExample(
|
||||
tool_name=tool_name,
|
||||
arguments=arguments,
|
||||
result="", # Will be filled from tool response
|
||||
success=True
|
||||
))
|
||||
except json.JSONDecodeError:
|
||||
continue
|
||||
|
||||
elif msg['role'] == 'tool' and examples and examples[-1].result == "":
|
||||
examples[-1].result = msg['content'] or ""
|
||||
|
||||
return examples
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to extract from session {session_id}: {e}")
|
||||
return []
|
||||
|
||||
def create_template(self, session_id: str, name: Optional[str] = None,
|
||||
task_type: Optional[TaskType] = None,
|
||||
max_examples: int = 10) -> Optional[SessionTemplate]:
|
||||
"""Create a template from a session."""
|
||||
examples = self.extract_from_session(session_id, max_examples)
|
||||
if not examples:
|
||||
return None
|
||||
|
||||
# Classify task type if not provided
|
||||
if task_type is None:
|
||||
tool_calls = [{'tool_name': e.tool_name} for e in examples]
|
||||
task_type = self.classify_task_type(tool_calls)
|
||||
|
||||
# Generate name if not provided
|
||||
if name is None:
|
||||
name = f"{task_type.value}_{session_id[:8]}_{int(time.time())}"
|
||||
|
||||
# Create template
|
||||
template = SessionTemplate(
|
||||
name=name,
|
||||
task_type=task_type,
|
||||
examples=examples,
|
||||
description=f"Template with {len(examples)} examples",
|
||||
source_session_id=session_id
|
||||
)
|
||||
|
||||
# Save template
|
||||
self.templates[name] = template
|
||||
self._save_template(template)
|
||||
|
||||
logger.info(f"Created template {name} with {len(examples)} examples")
|
||||
return template
|
||||
|
||||
def get_template(self, task_type: TaskType) -> Optional[SessionTemplate]:
|
||||
"""Get the best template for a task type."""
|
||||
matching = [t for t in self.templates.values() if t.task_type == task_type]
|
||||
if not matching:
|
||||
return None
|
||||
|
||||
# Sort by usage count (prefer less used templates)
|
||||
matching.sort(key=lambda t: t.usage_count)
|
||||
return matching[0]
|
||||
|
||||
def inject_into_messages(self, template: SessionTemplate,
|
||||
messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
|
||||
"""Inject template examples into messages."""
|
||||
if not template.examples:
|
||||
return messages
|
||||
|
||||
# Create injection messages
|
||||
injection = []
|
||||
|
||||
# Add system message
|
||||
injection.append({
|
||||
"role": "system",
|
||||
"content": f"Session template: {template.name} ({template.task_type.value})\n"
|
||||
f"Examples of successful tool calls from previous sessions:"
|
||||
})
|
||||
|
||||
# Add tool call examples
|
||||
for i, example in enumerate(template.examples):
|
||||
# Assistant message with tool call
|
||||
injection.append({
|
||||
"role": "assistant",
|
||||
"content": None,
|
||||
"tool_calls": [{
|
||||
"id": f"template_{i}",
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": example.tool_name,
|
||||
"arguments": json.dumps(example.arguments)
|
||||
}
|
||||
}]
|
||||
})
|
||||
|
||||
# Tool response
|
||||
injection.append({
|
||||
"role": "tool",
|
||||
"tool_call_id": f"template_{i}",
|
||||
"content": example.result
|
||||
})
|
||||
|
||||
# Insert after system messages
|
||||
insert_index = 0
|
||||
for i, msg in enumerate(messages):
|
||||
if msg.get("role") != "system":
|
||||
break
|
||||
insert_index = i + 1
|
||||
|
||||
# Insert injection
|
||||
for i, msg in enumerate(injection):
|
||||
messages.insert(insert_index + i, msg)
|
||||
|
||||
# Update usage count
|
||||
template.usage_count += 1
|
||||
self._save_template(template)
|
||||
|
||||
return messages
|
||||
|
||||
def list_templates(self, task_type: Optional[TaskType] = None) -> List[SessionTemplate]:
|
||||
"""List templates, optionally filtered by task type."""
|
||||
templates = list(self.templates.values())
|
||||
if task_type:
|
||||
templates = [t for t in templates if t.task_type == task_type]
|
||||
templates.sort(key=lambda t: t.created_at, reverse=True)
|
||||
return templates
|
||||
|
||||
def delete_template(self, name: str) -> bool:
|
||||
"""Delete a template."""
|
||||
if name not in self.templates:
|
||||
return False
|
||||
|
||||
del self.templates[name]
|
||||
template_file = self.template_dir / f"{name}.json"
|
||||
if template_file.exists():
|
||||
template_file.unlink()
|
||||
|
||||
logger.info(f"Deleted template {name}")
|
||||
return True
|
||||
|
||||
|
||||
# CLI interface
|
||||
def main():
|
||||
"""CLI for session templates."""
|
||||
import argparse
|
||||
|
||||
parser = argparse.ArgumentParser(description="Session Templates")
|
||||
subparsers = parser.add_subparsers(dest="command")
|
||||
|
||||
# List templates
|
||||
list_parser = subparsers.add_parser("list", help="List templates")
|
||||
list_parser.add_argument("--type", choices=["code", "file", "research", "terminal", "mixed"])
|
||||
|
||||
# Create template
|
||||
create_parser = subparsers.add_parser("create", help="Create template from session")
|
||||
create_parser.add_argument("session_id", help="Session ID")
|
||||
create_parser.add_argument("--name", help="Template name")
|
||||
create_parser.add_argument("--type", choices=["code", "file", "research", "terminal", "mixed"])
|
||||
create_parser.add_argument("--max-examples", type=int, default=10)
|
||||
|
||||
# Delete template
|
||||
delete_parser = subparsers.add_parser("delete", help="Delete template")
|
||||
delete_parser.add_argument("name", help="Template name")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
templates = SessionTemplates()
|
||||
|
||||
if args.command == "list":
|
||||
task_type = TaskType(args.type) if args.type else None
|
||||
template_list = templates.list_templates(task_type)
|
||||
|
||||
if not template_list:
|
||||
print("No templates found")
|
||||
return
|
||||
|
||||
print(f"Found {len(template_list)} templates:")
|
||||
for t in template_list:
|
||||
print(f" {t.name}: {t.task_type.value} ({len(t.examples)} examples, used {t.usage_count} times)")
|
||||
|
||||
elif args.command == "create":
|
||||
task_type = TaskType(args.type) if args.type else None
|
||||
template = templates.create_template(
|
||||
args.session_id,
|
||||
name=args.name,
|
||||
task_type=task_type,
|
||||
max_examples=args.max_examples
|
||||
)
|
||||
|
||||
if template:
|
||||
print(f"Created template: {template.name}")
|
||||
print(f" Type: {template.task_type.value}")
|
||||
print(f" Examples: {len(template.examples)}")
|
||||
else:
|
||||
print("Failed to create template")
|
||||
|
||||
elif args.command == "delete":
|
||||
if templates.delete_template(args.name):
|
||||
print(f"Deleted template: {args.name}")
|
||||
else:
|
||||
print(f"Template not found: {args.name}")
|
||||
|
||||
else:
|
||||
parser.print_help()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user