@reconcrap/people-network-memory 0.1.0

package/src/people_network_memory/graphiti_adapter/indexer.py

@@ -0,0 +1,194 @@
+"""Resumable Graphiti indexing for canonical local interactions."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Callable
+
+from people_network_memory.config import PeopleMemoryConfig
+from people_network_memory.domain.models import Evidence, SocialInteraction
+from people_network_memory.graphiti_adapter.graphiti_store import GraphitiGraphStore
+from people_network_memory.infrastructure.file_store import JsonPeopleStore, local_json_path
+
+
+IndexOne = Callable[[SocialInteraction], Evidence]
+CacheOne = Callable[[SocialInteraction], None]
+
+
+def index_local_json_to_graphiti(
+    config: PeopleMemoryConfig,
+    *,
+    source_data_path: str | Path | None = None,
+    state_path: str | Path | None = None,
+    limit: int | None = None,
+    resume: bool = True,
+    reset_state: bool = False,
+    continue_on_error: bool = False,
+) -> dict[str, object]:
+    source_path = Path(source_data_path).expanduser() if source_data_path else local_json_path(config)
+    state = _state_file(config, state_path)
+    source_store = JsonPeopleStore(source_path)
+    graph_config = config if config.backend == "graphiti" else _as_graphiti_config(config)
+    graph_store = GraphitiGraphStore.from_config(graph_config)
+    try:
+        return index_interactions(
+            list(source_store.interactions.values()),
+            state_path=state,
+            source_path=source_path,
+            graphiti_kuzu_path=Path(graph_config.graphiti_kuzu_path).expanduser(),
+            limit=limit,
+            resume=resume,
+            reset_state=reset_state,
+            continue_on_error=continue_on_error,
+            index_one=graph_store.index_interaction_episode,
+            cache_one=graph_store.cache_interaction_projection,
+        )
+    finally:
+        graph_store.close()
+
+
+def index_interactions(
+    interactions: list[SocialInteraction],
+    *,
+    state_path: Path,
+    source_path: Path,
+    graphiti_kuzu_path: Path,
+    limit: int | None,
+    resume: bool,
+    reset_state: bool,
+    continue_on_error: bool,
+    index_one: IndexOne,
+    cache_one: CacheOne | None = None,
+) -> dict[str, object]:
+    if reset_state and state_path.exists():
+        state_path.unlink()
+    state = _load_state(state_path)
+    state.setdefault("source_path", str(source_path))
+    state.setdefault("graphiti_kuzu_path", str(graphiti_kuzu_path))
+    indexed = state.setdefault("indexed", {})
+    failures = state.setdefault("failures", [])
+    started_at = datetime.now(timezone.utc).isoformat()
+    attempted = 0
+    indexed_count = 0
+    skipped = 0
+    failed = 0
+    entries: list[dict[str, object]] = []
+    stop_reason = "complete"
+    for index, interaction in enumerate(interactions):
+        if limit is not None and attempted >= limit:
+            stop_reason = "limit_reached"
+            break
+        fingerprint = interaction_fingerprint(interaction)
+        if resume and fingerprint in indexed:
+            if cache_one is not None:
+                cache_one(interaction)
+            skipped += 1
+            continue
+        attempted += 1
+        entry: dict[str, object] = {
+            "interaction_index": index,
+            "fingerprint": fingerprint,
+            "source_text": interaction.source_text,
+        }
+        try:
+            evidence = index_one(interaction)
+        except Exception as exc:  # pragma: no cover - concrete Graphiti failures are live
+            failed += 1
+            entry.update({"ok": False, "error": str(exc)})
+            failures.append(
+                {
+                    **entry,
+                    "failed_at": datetime.now(timezone.utc).isoformat(),
+                }
+            )
+            entries.append(entry)
+            _write_state(state_path, state)
+            if not continue_on_error:
+                stop_reason = "failed"
+                break
+            continue
+        indexed[fingerprint] = {
+            "interaction_index": index,
+            "evidence_id": evidence.evidence_id,
+            "indexed_at": datetime.now(timezone.utc).isoformat(),
+        }
+        if failures:
+            failures[:] = [
+                failure
+                for failure in failures
+                if failure.get("fingerprint") != fingerprint
+            ]
+        if cache_one is not None:
+            cache_one(interaction)
+        indexed_count += 1
+        entry.update({"ok": True, "evidence_id": evidence.evidence_id})
+        entries.append(entry)
+        _write_state(state_path, state)
+    finished_at = datetime.now(timezone.utc).isoformat()
+    state["last_run"] = {
+        "started_at": started_at,
+        "finished_at": finished_at,
+        "attempted": attempted,
+        "indexed": indexed_count,
+        "skipped": skipped,
+        "failed": failed,
+        "stop_reason": stop_reason,
+    }
+    _write_state(state_path, state)
+    ok = failed == 0 and stop_reason in {"complete", "limit_reached"}
+    return {
+        "ok": ok,
+        "source_path": str(source_path),
+        "state_path": str(state_path),
+        "graphiti_kuzu_path": str(graphiti_kuzu_path),
+        "total_interactions": len(interactions),
+        "attempted": attempted,
+        "indexed": indexed_count,
+        "state_indexed_total": len(indexed),
+        "skipped": skipped,
+        "failed": failed,
+        "stop_reason": stop_reason,
+        "resume": resume,
+        "limit": limit,
+        "entries": entries,
+    }
+
+
+def interaction_fingerprint(interaction: SocialInteraction) -> str:
+    serialized = interaction.model_dump_json()
+    return hashlib.sha256(serialized.encode("utf-8")).hexdigest()
+
+
+def _as_graphiti_config(config: PeopleMemoryConfig) -> PeopleMemoryConfig:
+    from dataclasses import replace
+
+    return replace(config, backend="graphiti")
+
+
+def _state_file(config: PeopleMemoryConfig, state_path: str | Path | None) -> Path:
+    if state_path:
+        return Path(state_path).expanduser()
+    return Path(config.data_path).expanduser() / "graphiti-index-state.json"
+
+
+def _load_state(path: Path) -> dict[str, object]:
+    if not path.exists():
+        return {"schema_version": 1, "indexed": {}, "failures": []}
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        return {"schema_version": 1, "indexed": {}, "failures": []}
+    payload.setdefault("schema_version", 1)
+    payload.setdefault("indexed", {})
+    payload.setdefault("failures", [])
+    return payload
+
+
+def _write_state(path: Path, state: dict[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(state, ensure_ascii=False, indent=2, sort_keys=True),
+        encoding="utf-8",
+    )

package/src/people_network_memory/graphiti_adapter/ontology.py

@@ -0,0 +1,68 @@
+"""Minimal social-memory ontology for Graphiti custom entity/edge mapping."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class OntologyModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class Person(OntologyModel):
+    aliases: list[str] = []
+
+
+class Organization(OntologyModel):
+    organization_type: str | None = None
+
+
+class Place(OntologyModel):
+    place_type: str | None = None
+
+
+class SocialEvent(OntologyModel):
+    event_type: str | None = None
+
+
+class TopicOrInterest(OntologyModel):
+    category: str | None = None
+
+
+class MetWith(OntologyModel):
+    context: str | None = None
+
+
+class MentionedPerson(OntologyModel):
+    context: str | None = None
+
+
+class DiscussedTopic(OntologyModel):
+    context: str | None = None
+
+
+class WorksAt(OntologyModel):
+    role: str | None = None
+    is_current: bool | None = None
+
+
+class StudiedAt(OntologyModel):
+    degree: str | None = None
+    major: str | None = None
+
+
+ENTITY_TYPES = {
+    "Person": Person,
+    "Organization": Organization,
+    "Place": Place,
+    "SocialEvent": SocialEvent,
+    "TopicOrInterest": TopicOrInterest,
+}
+
+EDGE_TYPES = {
+    "MetWith": MetWith,
+    "MentionedPerson": MentionedPerson,
+    "DiscussedTopic": DiscussedTopic,
+    "WorksAt": WorksAt,
+    "StudiedAt": StudiedAt,
+}

package/src/people_network_memory/harness_adapters/__init__.py

@@ -0,0 +1,2 @@
+"""Harness adapter package placeholder."""
+

package/src/people_network_memory/harness_adapters/openclaw/__init__.py

@@ -0,0 +1,9 @@
+"""OpenClaw adapter package."""
+
+from people_network_memory.harness_adapters.openclaw.installer import (
+    SERVER_ID,
+    install_openclaw_adapter,
+    openclaw_checks,
+)
+
+__all__ = ["SERVER_ID", "install_openclaw_adapter", "openclaw_checks"]