Skip to content

The agent that grows with you

3.7 KB
Raw Blame
"""ACP historical catalog without storage initialization or an execution owner."""
import json
from pathlib import Path

from hermes_state import SessionDB
from acp_adapter.session import (
    _normalize_cwd_for_compare, _parse_model_config, _session_info, _updated_at_sort_key,
)


def read_catalog_rows(path):
    path = Path(path)
    if not path.exists():
        return {}
    from hermes_cli.gateway_session_store import SurfaceLabelReader
    # The owner stores an editor thread as ``local`` with ``created_source='acp'``; the surface
    # reader matches both labels in SQL, before the LIMIT.
    with SessionDB(db_path=path, read_only=True) as db:
        rows = SurfaceLabelReader(db).list_sessions_rich(source="acp", limit=1000)
        return {str(row["id"]): dict(row) for row in rows}


def _local_owners(db):
    """Physical id -> retained logical owner, from each private local creation receipt's lineage.
    A canonical reset or compression advances the receipt's physical target but keeps policy/FIFO
    on the creation id. Legacy reset histories have no receipt and stay independent chats."""
    from hermes_state_local import POLICY_PREFIX
    owners = {}
    with db._read_ctx() as conn:
        rows = conn.execute('SELECT value FROM state_meta WHERE key GLOB ?', (POLICY_PREFIX + '*',)).fetchall()
    for (raw,) in rows:
        try:
            receipt = json.loads(raw)
        except (TypeError, ValueError):
            continue
        owner = receipt.get('session_id') if isinstance(receipt, dict) else None
        lineage = receipt.get('lineage') if isinstance(owner, str) else None
        for physical in lineage if isinstance(lineage, list) else ():
            if isinstance(physical, str):
                owners[physical] = owner
    return owners


def read_local_owners(path):
    path = Path(path)
    if not path.exists():
        return {}
    with SessionDB(db_path=path, read_only=True) as db:
        return _local_owners(db)


def logical_session_id(path, session_id):
    """The authority's logical id for an id an editor already holds: compression and a canonical
    reset advance the physical transcript, never the session identity (the local receipt's owner,
    else ``SessionAuthority.logical_owner``'s compression root)."""
    path = Path(path)
    if not path.exists():
        return session_id
    with SessionDB(db_path=path, read_only=True) as db:
        lineage = db.get_compression_lineage(session_id)
        root = lineage[0] if lineage else session_id
        return _local_owners(db).get(root, root)


def catalog_sessions(path, cwd=None):
    normalized = _normalize_cwd_for_compare(cwd) if cwd else None
    owners = read_local_owners(path)
    results = {}
    for sid, row in read_catalog_rows(path).items():
        # The listing projects a compressed chat's tip; the editor must hold the logical id.
        sid = row.get("_lineage_root_id") or sid
        sid = owners.get(sid, sid)
        count = int(row.get("message_count") or 0)
        session_cwd = row.get('cwd') or _parse_model_config(row.get("model_config")).get("cwd", ".")
        if count <= 0 or (normalized and _normalize_cwd_for_compare(session_cwd) != normalized):
            continue
        info = _session_info(sid, session_cwd, row.get("model") or "", count, row.get("title"),
                             row.get("preview"), row.get("last_active") or row.get("started_at"))
        # One row per logical conversation: its most recently active segment represents it.
        held = results.get(sid)
        if held is None or _updated_at_sort_key(info.get("updated_at")) > _updated_at_sort_key(held.get("updated_at")):
            results[sid] = info
    return sorted(results.values(), key=lambda row: _updated_at_sort_key(row.get("updated_at")), reverse=True)