eidet-sdk 0.1.0__tar.gz

eidet_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: eidet-sdk
+Version: 0.1.0
+Summary: Python client SDK for Eidet — long-term memory for AI coding agents
+License: MIT
+Project-URL: Homepage, https://github.com/stevehansen/eidet
+Keywords: eidet,memory,ai,coding-agent,mcp
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+
+# eidet-sdk
+
+Python client SDK for [Eidet](https://github.com/stevehansen/eidet) — long-term memory for AI coding agents.
+
+## Install
+
+```bash
+pip install eidet-sdk
+```
+
+## Usage
+
+```python
+from eidet_sdk import EidetClient, StoreRequest, MemoryType
+
+client = EidetClient()  # defaults to http://localhost:19380
+
+# Store a memory
+result = client.store(StoreRequest(
+    repo="/path/to/project",
+    content="The auth module uses JWT with RS256 signing",
+    type=MemoryType.OBSERVATION,
+    tags=["auth", "jwt"],
+))
+
+# Search memories
+results = client.recall("/path/to/project", "authentication")
+
+# Get session context (L0 identity + L1 top memories, < 600 tokens)
+context = client.context("/path/to/project")
+
+# Browse all memories
+page = client.browse("/path/to/project", skip=0, take=50)
+
+# Feedback loop
+client.feedback("memories/...", was_used=True)   # echo (useful)
+client.feedback("memories/...", was_used=False)  # fizzle (irrelevant)
+```
+
+## Context Manager
+
+```python
+with EidetClient(url="http://localhost:19380") as client:
+    results = client.recall("/path/to/project", "deployment")
+```
+
+## API Key Authentication
+
+```python
+client = EidetClient(url="http://localhost:19380", api_key="your-api-key")
+```
+
+## All Methods
+
+| Method | Description |
+|--------|-------------|
+| `store(request)` | Store a memory (observation, insight, procedure, heuristic) |
+| `recall(repo, query, **kwargs)` | Search memories by meaning and keywords |
+| `context(repo)` | Get compact session context (< 600 tokens) |
+| `get_memory(id)` | Get a specific memory by ID |
+| `forget(id, reason?)` | Soft-delete a memory |
+| `feedback(memory_id, was_used)` | Echo (useful) or fizzle (irrelevant) feedback |
+| `history(id)` | Get version chain for a memory |
+| `browse(repo, **kwargs)` | Paginated memory listing |
+| `graph(repo, limit?)` | Graph data for visualization |
+| `repos()` | List all known repositories |
+| `intake(repo)` | Ingest project files as seed memories |
+| `consolidate(repo)` | Merge related observations into insights |
+| `maintenance(repo)` | Run maintenance pipeline |
+| `export_markdown(repo)` | Export memories as markdown |
+| `health()` | Health check |
+| `status()` | Service status and stats |
+
+## Requirements
+
+- Eidet service running locally (`eidet serve` or installed as system service)
+- Python 3.10+
+- httpx
+
+## License
+
+[MIT](https://github.com/stevehansen/eidet/blob/main/LICENSE)

eidet_sdk-0.1.0/README.md

@@ -0,0 +1,82 @@
+# eidet-sdk
+
+Python client SDK for [Eidet](https://github.com/stevehansen/eidet) — long-term memory for AI coding agents.
+
+## Install
+
+```bash
+pip install eidet-sdk
+```
+
+## Usage
+
+```python
+from eidet_sdk import EidetClient, StoreRequest, MemoryType
+
+client = EidetClient()  # defaults to http://localhost:19380
+
+# Store a memory
+result = client.store(StoreRequest(
+    repo="/path/to/project",
+    content="The auth module uses JWT with RS256 signing",
+    type=MemoryType.OBSERVATION,
+    tags=["auth", "jwt"],
+))
+
+# Search memories
+results = client.recall("/path/to/project", "authentication")
+
+# Get session context (L0 identity + L1 top memories, < 600 tokens)
+context = client.context("/path/to/project")
+
+# Browse all memories
+page = client.browse("/path/to/project", skip=0, take=50)
+
+# Feedback loop
+client.feedback("memories/...", was_used=True)   # echo (useful)
+client.feedback("memories/...", was_used=False)  # fizzle (irrelevant)
+```
+
+## Context Manager
+
+```python
+with EidetClient(url="http://localhost:19380") as client:
+    results = client.recall("/path/to/project", "deployment")
+```
+
+## API Key Authentication
+
+```python
+client = EidetClient(url="http://localhost:19380", api_key="your-api-key")
+```
+
+## All Methods
+
+| Method | Description |
+|--------|-------------|
+| `store(request)` | Store a memory (observation, insight, procedure, heuristic) |
+| `recall(repo, query, **kwargs)` | Search memories by meaning and keywords |
+| `context(repo)` | Get compact session context (< 600 tokens) |
+| `get_memory(id)` | Get a specific memory by ID |
+| `forget(id, reason?)` | Soft-delete a memory |
+| `feedback(memory_id, was_used)` | Echo (useful) or fizzle (irrelevant) feedback |
+| `history(id)` | Get version chain for a memory |
+| `browse(repo, **kwargs)` | Paginated memory listing |
+| `graph(repo, limit?)` | Graph data for visualization |
+| `repos()` | List all known repositories |
+| `intake(repo)` | Ingest project files as seed memories |
+| `consolidate(repo)` | Merge related observations into insights |
+| `maintenance(repo)` | Run maintenance pipeline |
+| `export_markdown(repo)` | Export memories as markdown |
+| `health()` | Health check |
+| `status()` | Service status and stats |
+
+## Requirements
+
+- Eidet service running locally (`eidet serve` or installed as system service)
+- Python 3.10+
+- httpx
+
+## License
+
+[MIT](https://github.com/stevehansen/eidet/blob/main/LICENSE)

eidet_sdk-0.1.0/eidet_sdk/__init__.py

@@ -0,0 +1,4 @@
+from .client import EidetClient, EidetError, MemoryType, StoreRequest
+
+__all__ = ["EidetClient", "EidetError", "MemoryType", "StoreRequest"]
+__version__ = "0.1.0"

eidet_sdk-0.1.0/eidet_sdk/client.py

@@ -0,0 +1,187 @@
+"""Eidet Python SDK — REST API client for Eidet memory service."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+import httpx
+
+
+class MemoryType(str, Enum):
+    OBSERVATION = "observation"
+    INSIGHT = "insight"
+    PROCEDURE = "procedure"
+    HEURISTIC = "heuristic"
+
+
+@dataclass
+class StoreRequest:
+    repo: str
+    content: str
+    type: MemoryType = MemoryType.OBSERVATION
+    tags: list[str] = field(default_factory=list)
+    importance: float = 0.5
+    source: str = "sdk"
+    session_id: str | None = None
+    supersedes: str | None = None
+
+
+class EidetError(Exception):
+    def __init__(self, status: int, body: str) -> None:
+        self.status = status
+        self.body = body
+        super().__init__(f"Eidet API error {status}: {body}")
+
+
+class EidetClient:
+    """Client for the Eidet memory service REST API."""
+
+    def __init__(self, url: str = "http://localhost:19380", api_key: str | None = None) -> None:
+        self._base = url.rstrip("/")
+        headers: dict[str, str] = {}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        self._client = httpx.Client(base_url=self._base, headers=headers, timeout=30.0)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> EidetClient:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    # ─── Core operations ─────────────────────────────────────────
+
+    def store(
+        self,
+        repo: str,
+        content: str,
+        type: MemoryType | str = MemoryType.OBSERVATION,
+        *,
+        tags: list[str] | None = None,
+        importance: float = 0.5,
+        source: str = "sdk",
+        session_id: str | None = None,
+        supersedes: str | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {
+            "repo": repo,
+            "content": content,
+            "type": str(type.value) if isinstance(type, MemoryType) else type,
+            "importance": importance,
+            "source": source,
+        }
+        if tags:
+            body["tags"] = tags
+        if session_id:
+            body["sessionId"] = session_id
+        if supersedes:
+            body["supersedes"] = supersedes
+        return self._post("/api/eidet", body)
+
+    def recall(
+        self,
+        repo: str,
+        query: str,
+        *,
+        limit: int = 10,
+        type: MemoryType | str | None = None,
+        tags: list[str] | None = None,
+    ) -> list[dict[str, Any]]:
+        params: dict[str, str] = {"repo": repo, "q": query, "limit": str(limit)}
+        if type:
+            params["type"] = str(type.value) if isinstance(type, MemoryType) else type
+        if tags:
+            params["tags"] = ",".join(tags)
+        data = self._get("/api/eidet/search", params=params)
+        return data["results"]
+
+    def context(self, repo: str) -> str:
+        data = self._get("/api/eidet/context", params={"repo": repo})
+        return data["context"]
+
+    def get_memory(self, memory_id: str) -> dict[str, Any]:
+        return self._get(f"/api/eidet/{memory_id}")
+
+    def forget(self, memory_id: str, reason: str | None = None) -> bool:
+        params = {"reason": reason} if reason else {}
+        data = self._delete(f"/api/eidet/{memory_id}", params=params)
+        return data.get("forgotten", False)
+
+    def feedback(self, memory_id: str, was_used: bool) -> bool:
+        data = self._post("/api/eidet/feedback", {"memoryId": memory_id, "wasUsed": was_used})
+        return data.get("applied", False)
+
+    def history(self, memory_id: str) -> list[dict[str, Any]]:
+        data = self._get(f"/api/eidet/history/{memory_id}")
+        return data["chain"]
+
+    # ─── Browse & Graph ──────────────────────────────────────────
+
+    def browse(
+        self,
+        repo: str,
+        *,
+        skip: int = 0,
+        take: int = 50,
+        type: MemoryType | str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, str] = {"repo": repo, "skip": str(skip), "take": str(take)}
+        if type:
+            params["type"] = str(type.value) if isinstance(type, MemoryType) else type
+        return self._get("/api/eidet/browse", params=params)
+
+    def graph(self, repo: str, limit: int = 200) -> dict[str, Any]:
+        return self._get("/api/eidet/graph", params={"repo": repo, "limit": str(limit)})
+
+    def repos(self) -> list[str]:
+        data = self._get("/api/eidet/repos")
+        return [r["repoId"] for r in data["repos"]]
+
+    # ─── Operations ──────────────────────────────────────────────
+
+    def intake(self, repo: str) -> dict[str, Any]:
+        return self._post(f"/api/eidet/intake?repo={repo}")
+
+    def consolidate(self, repo: str) -> dict[str, Any]:
+        return self._post(f"/api/eidet/consolidate?repo={repo}")
+
+    def maintenance(self, repo: str) -> dict[str, Any]:
+        return self._post(f"/api/maintenance?repo={repo}")
+
+    def export_markdown(self, repo: str) -> str:
+        res = self._client.get("/api/eidet/export", params={"repo": repo})
+        res.raise_for_status()
+        return res.text
+
+    # ─── Health ──────────────────────────────────────────────────
+
+    def health(self) -> dict[str, Any]:
+        return self._get("/api/health")
+
+    def status(self) -> dict[str, Any]:
+        return self._get("/api/status")
+
+    # ─── HTTP helpers ────────────────────────────────────────────
+
+    def _get(self, path: str, params: dict[str, str] | None = None) -> dict[str, Any]:
+        res = self._client.get(path, params=params)
+        if not res.is_success:
+            raise EidetError(res.status_code, res.text)
+        return res.json()
+
+    def _post(self, path: str, body: dict[str, Any] | None = None) -> dict[str, Any]:
+        res = self._client.post(path, json=body)
+        if not res.is_success:
+            raise EidetError(res.status_code, res.text)
+        return res.json()
+
+    def _delete(self, path: str, params: dict[str, str] | None = None) -> dict[str, Any]:
+        res = self._client.delete(path, params=params)
+        if not res.is_success:
+            raise EidetError(res.status_code, res.text)
+        return res.json()

eidet_sdk-0.1.0/eidet_sdk.egg-info/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: eidet-sdk
+Version: 0.1.0
+Summary: Python client SDK for Eidet — long-term memory for AI coding agents
+License: MIT
+Project-URL: Homepage, https://github.com/stevehansen/eidet
+Keywords: eidet,memory,ai,coding-agent,mcp
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+
+# eidet-sdk
+
+Python client SDK for [Eidet](https://github.com/stevehansen/eidet) — long-term memory for AI coding agents.
+
+## Install
+
+```bash
+pip install eidet-sdk
+```
+
+## Usage
+
+```python
+from eidet_sdk import EidetClient, StoreRequest, MemoryType
+
+client = EidetClient()  # defaults to http://localhost:19380
+
+# Store a memory
+result = client.store(StoreRequest(
+    repo="/path/to/project",
+    content="The auth module uses JWT with RS256 signing",
+    type=MemoryType.OBSERVATION,
+    tags=["auth", "jwt"],
+))
+
+# Search memories
+results = client.recall("/path/to/project", "authentication")
+
+# Get session context (L0 identity + L1 top memories, < 600 tokens)
+context = client.context("/path/to/project")
+
+# Browse all memories
+page = client.browse("/path/to/project", skip=0, take=50)
+
+# Feedback loop
+client.feedback("memories/...", was_used=True)   # echo (useful)
+client.feedback("memories/...", was_used=False)  # fizzle (irrelevant)
+```
+
+## Context Manager
+
+```python
+with EidetClient(url="http://localhost:19380") as client:
+    results = client.recall("/path/to/project", "deployment")
+```
+
+## API Key Authentication
+
+```python
+client = EidetClient(url="http://localhost:19380", api_key="your-api-key")
+```
+
+## All Methods
+
+| Method | Description |
+|--------|-------------|
+| `store(request)` | Store a memory (observation, insight, procedure, heuristic) |
+| `recall(repo, query, **kwargs)` | Search memories by meaning and keywords |
+| `context(repo)` | Get compact session context (< 600 tokens) |
+| `get_memory(id)` | Get a specific memory by ID |
+| `forget(id, reason?)` | Soft-delete a memory |
+| `feedback(memory_id, was_used)` | Echo (useful) or fizzle (irrelevant) feedback |
+| `history(id)` | Get version chain for a memory |
+| `browse(repo, **kwargs)` | Paginated memory listing |
+| `graph(repo, limit?)` | Graph data for visualization |
+| `repos()` | List all known repositories |
+| `intake(repo)` | Ingest project files as seed memories |
+| `consolidate(repo)` | Merge related observations into insights |
+| `maintenance(repo)` | Run maintenance pipeline |
+| `export_markdown(repo)` | Export memories as markdown |
+| `health()` | Health check |
+| `status()` | Service status and stats |
+
+## Requirements
+
+- Eidet service running locally (`eidet serve` or installed as system service)
+- Python 3.10+
+- httpx
+
+## License
+
+[MIT](https://github.com/stevehansen/eidet/blob/main/LICENSE)

eidet_sdk-0.1.0/eidet_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+eidet_sdk/__init__.py
+eidet_sdk/client.py
+eidet_sdk.egg-info/PKG-INFO
+eidet_sdk.egg-info/SOURCES.txt
+eidet_sdk.egg-info/dependency_links.txt
+eidet_sdk.egg-info/requires.txt
+eidet_sdk.egg-info/top_level.txt

eidet_sdk-0.1.0/eidet_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

eidet_sdk-0.1.0/eidet_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx>=0.27

eidet_sdk-0.1.0/eidet_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+eidet_sdk

eidet_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eidet-sdk"
+version = "0.1.0"
+description = "Python client SDK for Eidet — long-term memory for AI coding agents"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+keywords = ["eidet", "memory", "ai", "coding-agent", "mcp"]
+dependencies = ["httpx>=0.27"]
+
+[project.urls]
+Homepage = "https://github.com/stevehansen/eidet"

eidet_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+