mirror of
https://github.com/sipeed/picoclaw.git
synced 2026-05-25 16:00:35 +00:00
Liu Yuan
15a70ac45c
* feat(seahorse): implement short-term memory engine of seahorse Add pkg/seahorse/ module implementing a SQLite-backed DAG-based summary hierarchy for context management, ported from lossless-claw's LCM design: - types.go + short_constants.go: core types (Message, Summary, Conversation, ContextItem) and configuration constants (fanout, token targets, thresholds) - migration.go: idempotent DB schema with FTS5 trigram tokenizer for CJK - store.go: full SQLite CRUD (conversations, messages, summaries DAG, context_items with ordinal gap numbering, FTS5 search) - short_engine.go: Engine lifecycle (NewEngine, Ingest, Assemble, Compact), session pattern filtering (ignore/stateless glob→regex compilation), per-session mutex via sync.Map - short_assembler.go: budget-aware context assembly with fresh tail protection (32 messages), oldest-first eviction, summary XML formatting, RebuildContextItems - short_compaction.go: leaf compaction (messages→summary) and condensed compaction (summaries→higher-level summary), 3-level LLM escalation, CompactUntilUnder for emergency overflow - short_retrieval.go: lookupByID, FTS5/LIKE search, recursive expand with token cap - context_seahorse.go: agent.ContextManager adapter, registered as "seahorse", provider↔seahorse message type conversion (ToolCalls, tool_result) * fix(seahorse): correct 3 adapter bugs in context management - TokenCount: use full message (Content+ToolCalls+Media) instead of Content-only - Empty Content: rebuild Content from tool_result Parts when stored empty - Duplicate summaries: summaries only in Summary field, not in History messages - Grep: fix SearchResult.Snippet→Content for summaries - Schema: fix FTS5 SQL uses VIRTUAL TABLE not TEMP TABLE - TestFTS5SQLConstants: verify FTS5 SQL syntax correctness - Test: fix flaky TestCompactLeaf * fix(agent): ingest steering messages into seahorse SQLite Steering messages were only persisted to session JSONL but not ingested into seahorse SQLite, causing them to be missing from context assembly. Added `ts.ingestMessage(turnCtx, al, pm)` call in the steering message injection block alongside the existing JSONL persistence. Test: TestSeahorseSteeringMessageIngested verifies steering messages appear in seahorse SQLite DB after being processed. * fix(seahorse): address 3 blocking bugs from code review - Fix resequenceContextItemsTx scan error handling (store.go:850) Changed `return err` to `return scanErr` to properly propagate scan errors instead of returning nil (which silently corrupts data) - Fix sql.NullString for INTEGER column (store.go:847) Changed `mid` from sql.NullString to sql.NullInt64 since message_id is INTEGER in schema. Removed unnecessary strconv.ParseInt call. - Fix compactCondensed fallback deleting non-candidate items Added ReplaceContextItemsWithSummary method for per-item deletion when candidates are not contiguous in ordinal space. Optimized to use range deletion when candidates are consecutive. * fix(seahorse): pass Budget to Compact for correct condensed threshold Issue #4 from PR review: When Budget was not passed to seahorse.Compact, it defaulted to `tokensBefore * 0.75`, making `tokensBefore > budget` always true and causing condensed compaction to trigger unnecessarily. Changes: - context_seahorse.go: Forward Budget from CompactRequest to CompactInput - loop.go: Pass Budget (ContextWindow) in all 3 Compact calls - Add test verifying condensed is skipped when tokens < threshold - Fix lint issues in store.go and store_test.go * fix(seahorse): add mutex for assembler lazy initialization Issue #5 from PR review: The check-then-create pattern for e.assembler was a data race when multiple goroutines called Assemble() concurrently: if e.assembler == nil { e.assembler = &Assembler{...} } Changes: - Add assemblerMu sync.Mutex to Engine struct - Add initAssemblerOnce() using double-checked locking (same pattern as initCompactionOnce) - Add TestAssemblerLazyInitRace to verify thread-safety * fix(seahorse): handle non-consecutive depths in selectShallowestCondensationCandidate Issue #8 from PR review: the loop iterated depth 0, 1, 2... assuming consecutive keys, but break when key was missing caused deeper depths to never be checked. Fix: collect all existing depth keys, sort, then iterate in order. * fix(seahorse): wrap DeleteMessagesAfterID and appendContextItems in transactions - DeleteMessagesAfterID: wrap all DELETE operations in a transaction for atomicity, remove redundant manual FTS delete (handled by trigger) - appendContextItems: use transaction to fix read-then-write race condition - Add GetMaxOrdinalTx and resolveItemTokenCountTx for transaction-scoped queries - Remove unused resolveItemTokenCount function Fixes PR review issues 6 and 7. * fix(seahorse): derive readable content from Parts and cap CompactUntilUnder iterations - Derive readable content from MessageParts in AddMessageWithParts so FTS5 indexing and summary formatting can access tool call information - formatMessagesForSummary and truncateSummary now fall back to Parts when Content is empty, fixing blank summaries for Part-based messages - Add MaxCompactIterations (20) to prevent CompactUntilUnder infinite loops; exceeded iterations are logged as warnings
87 lines
2.6 KiB
Go
87 lines
2.6 KiB
Go
package session
|
|
|
|
import (
|
|
"context"
|
|
"log"
|
|
|
|
"github.com/sipeed/picoclaw/pkg/memory"
|
|
"github.com/sipeed/picoclaw/pkg/providers"
|
|
)
|
|
|
|
// JSONLBackend adapts a memory.Store into the SessionStore interface.
|
|
// Write errors are logged rather than returned, matching the fire-and-forget
|
|
// contract of SessionManager that the agent loop relies on.
|
|
type JSONLBackend struct {
|
|
store memory.Store
|
|
}
|
|
|
|
// NewJSONLBackend wraps a memory.Store for use as a SessionStore.
|
|
func NewJSONLBackend(store memory.Store) *JSONLBackend {
|
|
return &JSONLBackend{store: store}
|
|
}
|
|
|
|
func (b *JSONLBackend) AddMessage(sessionKey, role, content string) {
|
|
if err := b.store.AddMessage(context.Background(), sessionKey, role, content); err != nil {
|
|
log.Printf("session: add message: %v", err)
|
|
}
|
|
}
|
|
|
|
func (b *JSONLBackend) AddFullMessage(sessionKey string, msg providers.Message) {
|
|
if err := b.store.AddFullMessage(context.Background(), sessionKey, msg); err != nil {
|
|
log.Printf("session: add full message: %v", err)
|
|
}
|
|
}
|
|
|
|
func (b *JSONLBackend) GetHistory(key string) []providers.Message {
|
|
msgs, err := b.store.GetHistory(context.Background(), key)
|
|
if err != nil {
|
|
log.Printf("session: get history: %v", err)
|
|
return []providers.Message{}
|
|
}
|
|
return msgs
|
|
}
|
|
|
|
func (b *JSONLBackend) GetSummary(key string) string {
|
|
summary, err := b.store.GetSummary(context.Background(), key)
|
|
if err != nil {
|
|
log.Printf("session: get summary: %v", err)
|
|
return ""
|
|
}
|
|
return summary
|
|
}
|
|
|
|
func (b *JSONLBackend) SetSummary(key, summary string) {
|
|
if err := b.store.SetSummary(context.Background(), key, summary); err != nil {
|
|
log.Printf("session: set summary: %v", err)
|
|
}
|
|
}
|
|
|
|
func (b *JSONLBackend) SetHistory(key string, history []providers.Message) {
|
|
if err := b.store.SetHistory(context.Background(), key, history); err != nil {
|
|
log.Printf("session: set history: %v", err)
|
|
}
|
|
}
|
|
|
|
func (b *JSONLBackend) TruncateHistory(key string, keepLast int) {
|
|
if err := b.store.TruncateHistory(context.Background(), key, keepLast); err != nil {
|
|
log.Printf("session: truncate history: %v", err)
|
|
}
|
|
}
|
|
|
|
// Save persists session state. Since the JSONL store fsyncs every write
|
|
// immediately, the data is already durable. Save runs compaction to reclaim
|
|
// space from logically truncated messages (no-op when there are none).
|
|
func (b *JSONLBackend) Save(key string) error {
|
|
return b.store.Compact(context.Background(), key)
|
|
}
|
|
|
|
// Close releases resources held by the underlying store.
|
|
func (b *JSONLBackend) Close() error {
|
|
return b.store.Close()
|
|
}
|
|
|
|
// ListSessions returns all known session keys.
|
|
func (b *JSONLBackend) ListSessions() []string {
|
|
return b.store.ListSessions()
|
|
}
|