adaptive-memory-engine 0.1.6__py3-none-any.whl

ame/connectors/sync_history.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class ConnectorSyncRun(BaseModel):
+    id: str = Field(default_factory=lambda: f"sync_{uuid.uuid4().hex[:12]}")
+    corpus_id: str
+    connector: str
+    status: Literal["success", "failed"]
+    source: str | None = None
+    started_at: datetime
+    finished_at: datetime
+    counts: dict[str, int] = Field(default_factory=dict)
+    metadata: dict[str, str] = Field(default_factory=dict)
+    error: str | None = None
+
+
+class ConnectorSyncStore:
+    def __init__(self, corpus_root: Path):
+        self.corpus_root = corpus_root
+        self.path = corpus_root / "connectors" / "sync_history.jsonl"
+
+    def record(
+        self,
+        *,
+        connector: str,
+        status: Literal["success", "failed"],
+        started_at: datetime,
+        source: str | None = None,
+        counts: dict[str, int] | None = None,
+        metadata: dict[str, str] | None = None,
+        error: str | None = None,
+    ) -> ConnectorSyncRun:
+        run = ConnectorSyncRun(
+            corpus_id=self.corpus_root.name,
+            connector=connector,
+            status=status,
+            source=source,
+            started_at=started_at,
+            finished_at=datetime.now(timezone.utc),
+            counts=counts or {},
+            metadata=metadata or {},
+            error=error,
+        )
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.path.open("a", encoding="utf-8") as fh:
+            fh.write(run.model_dump_json() + "\n")
+        return run
+
+    def list(self, *, connector: str | None = None, limit: int | None = None) -> list[ConnectorSyncRun]:
+        if not self.path.exists():
+            return []
+        rows: list[ConnectorSyncRun] = []
+        for line in self.path.read_text(encoding="utf-8").splitlines():
+            if not line.strip():
+                continue
+            row = ConnectorSyncRun.model_validate(json.loads(line))
+            if connector and row.connector != connector:
+                continue
+            rows.append(row)
+        rows.sort(key=lambda run: run.started_at, reverse=True)
+        return rows[:limit] if limit else rows
+
+    def latest(self, *, connector: str | None = None) -> ConnectorSyncRun | None:
+        rows = self.list(connector=connector, limit=1)
+        return rows[0] if rows else None

ame/context_budget.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import hashlib
+import re
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ContextItem(BaseModel):
+    source_id: str
+    content: str
+    priority: float = 0.5
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class OptimizedContextItem(BaseModel):
+    source_id: str
+    content: str
+    original_hash: str
+    compression: str = "none"
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class ContextBudgetResult(BaseModel):
+    budget_chars: int
+    original_chars: int
+    optimized_chars: int
+    items: list[OptimizedContextItem] = Field(default_factory=list)
+    archive: dict[str, str] = Field(default_factory=dict)
+
+
+class ContextBudgetOptimizer:
+    def optimize(self, items: list[ContextItem], budget_chars: int) -> ContextBudgetResult:
+        if budget_chars < 1:
+            raise ValueError("budget_chars must be at least 1")
+        ordered = sorted(enumerate(items), key=lambda pair: (-pair[1].priority, pair[0]))
+        original_chars = sum(len(item.content) for item in items)
+        optimized: list[OptimizedContextItem] = []
+        archive: dict[str, str] = {}
+        remaining = budget_chars
+
+        for _index, item in ordered:
+            original_hash = _hash(item.content)
+            if remaining <= 0 and optimized:
+                archive[original_hash] = item.content
+                continue
+            if len(item.content) <= remaining:
+                content = item.content
+                compression = "none"
+            else:
+                content = _compress(item.content, max(1, remaining))
+                compression = "extractive"
+                archive[original_hash] = item.content
+            optimized.append(
+                OptimizedContextItem(
+                    source_id=item.source_id,
+                    content=content,
+                    original_hash=original_hash,
+                    compression=compression,
+                    metadata=item.metadata,
+                )
+            )
+            remaining = max(0, remaining - len(content))
+
+        optimized_chars = sum(len(item.content) for item in optimized)
+        return ContextBudgetResult(
+            budget_chars=budget_chars,
+            original_chars=original_chars,
+            optimized_chars=optimized_chars,
+            items=optimized,
+            archive=archive,
+        )
+
+    def restore(self, result: ContextBudgetResult) -> list[ContextItem]:
+        restored: list[ContextItem] = []
+        for item in result.items:
+            restored.append(
+                ContextItem(
+                    source_id=item.source_id,
+                    content=result.archive.get(item.original_hash, item.content),
+                    metadata=item.metadata,
+                )
+            )
+        return restored
+
+
+def _compress(content: str, limit: int) -> str:
+    lines = [line.strip() for line in content.splitlines() if line.strip()]
+    key_lines = [
+        line
+        for line in lines
+        if re.search(r"\b(decision|rationale|because|next action|todo|blocker|결정|근거|이유|할 일|차단)\b", line, re.I)
+    ]
+    selected = []
+    for line in lines[:2] + key_lines:
+        if line not in selected:
+            selected.append(line)
+    text = "\n".join(selected) if selected else content.strip()
+    if len(text) <= limit:
+        return text
+    return text[: max(0, limit - 1)].rstrip() + "…"
+
+
+def _hash(content: str) -> str:
+    return hashlib.sha256(content.encode("utf-8")).hexdigest()

ame/core/config.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+from ame.core.paths import ame_home
+
+
+class EngineConfig(BaseModel):
+    confidence_threshold: float = 0.7
+
+
+class StorageConfig(BaseModel):
+    home: str = "~/Library/Application Support/ame"
+
+
+class LightRagConfig(BaseModel):
+    backend: Literal["auto", "filesystem", "core"] = "auto"
+    query_mode: str = "hybrid"
+    ollama_host: str = "http://127.0.0.1:11434"
+    llm_model: str = "qwen3:8b"
+    embedding_model: str = "nomic-embed-text"
+    embedding_dim: int = 768
+    max_token_size: int = 8192
+
+
+class SlackConfig(BaseModel):
+    client_id: str = ""
+    client_secret: str = ""
+    redirect_uri: str = "http://localhost:8765/slack/oauth/callback"
+    scopes: list[str] = Field(
+        default_factory=lambda: [
+            "channels:read",
+            "channels:history",
+            "groups:read",
+            "groups:history",
+        ]
+    )
+
+
+class GoogleConfig(BaseModel):
+    client_id: str = ""
+    client_secret: str = ""
+    redirect_uri: str = "http://localhost:8765/google/oauth/callback"
+    scopes: list[str] = Field(
+        default_factory=lambda: [
+            "https://www.googleapis.com/auth/drive.readonly",
+            "https://www.googleapis.com/auth/gmail.readonly",
+            "https://www.googleapis.com/auth/calendar.readonly",
+            "https://www.googleapis.com/auth/spreadsheets.readonly",
+        ]
+    )
+
+
+class SecurityConfig(BaseModel):
+    token_backend: Literal["file", "keychain", "auto"] = "file"
+    pii_redaction: Literal["off", "metadata", "content"] = "off"
+
+
+class AmeConfig(BaseModel):
+    engine: EngineConfig = Field(default_factory=EngineConfig)
+    storage: StorageConfig = Field(default_factory=StorageConfig)
+    lightrag: LightRagConfig = Field(default_factory=LightRagConfig)
+    slack: SlackConfig = Field(default_factory=SlackConfig)
+    google: GoogleConfig = Field(default_factory=GoogleConfig)
+    security: SecurityConfig = Field(default_factory=SecurityConfig)
+
+
+def load_config(path: Path | None = None) -> AmeConfig:
+    config_path = path or ame_home() / "config.toml"
+    if not config_path.exists():
+        return AmeConfig()
+    data: dict[str, Any] = tomllib.loads(config_path.read_text(encoding="utf-8"))
+    return AmeConfig.model_validate(data)

ame/core/corpus.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ame.core.errors import CorpusNotFoundError
+from ame.core.paths import corpus_path, ensure_corpus_layout
+
+
+def create_corpus(corpus_id: str) -> Path:
+    return ensure_corpus_layout(corpus_id)
+
+
+def require_corpus(corpus_id: str) -> Path:
+    root = corpus_path(corpus_id)
+    if not root.exists():
+        raise CorpusNotFoundError(f"Corpus does not exist: {corpus_id}")
+    return root

ame/core/errors.py

@@ -0,0 +1,18 @@
+class AmeError(Exception):
+    """Base error for Adaptive Memory Engine."""
+
+
+class CorpusNotFoundError(AmeError):
+    pass
+
+
+class UnsupportedHardwareError(AmeError):
+    pass
+
+
+class LlmClientError(AmeError):
+    pass
+
+
+class LightRagBackendError(AmeError):
+    pass

ame/core/paths.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import os
+import platform
+from pathlib import Path
+
+from ame.gold.ontology import write_base_ontology
+from ame.models.registry import ModelRegistry
+from ame.security import ensure_private_dir, ensure_private_file
+
+
+def ame_home() -> Path:
+    override = os.environ.get("AME_HOME")
+    if override:
+        return Path(override).expanduser().resolve()
+    return default_ame_home()
+
+
+def default_ame_home() -> Path:
+    system = platform.system()
+    if system == "Darwin":
+        return Path("~/Library/Application Support/ame").expanduser()
+    if system == "Windows":
+        base = os.environ.get("LOCALAPPDATA") or os.environ.get("APPDATA")
+        if base:
+            return Path(base).expanduser() / "AdaptiveMemoryEngine"
+        return Path.home() / "AppData" / "Local" / "AdaptiveMemoryEngine"
+    xdg_data_home = os.environ.get("XDG_DATA_HOME")
+    if xdg_data_home:
+        return Path(xdg_data_home).expanduser() / "ame"
+    return Path("~/.local/share/ame").expanduser()
+
+
+def corpus_path(corpus_id: str) -> Path:
+    return ame_home() / "corpora" / corpus_id
+
+
+def ensure_runtime_layout() -> Path:
+    home = ame_home()
+    ensure_private_dir(home)
+    (home / "models").mkdir(parents=True, exist_ok=True)
+    (home / "corpora").mkdir(parents=True, exist_ok=True)
+    ensure_private_dir(home / "tokens")
+    ModelRegistry().write_cache(home / "registry.cache.yaml")
+    config = home / "config.toml"
+    if not config.exists():
+        config.write_text(
+            "\n".join(
+                [
+                    "[engine]",
+                    "confidence_threshold = 0.7",
+                    "",
+                    "[lightrag]",
+                    'backend = "auto"',
+                    'query_mode = "hybrid"',
+                    'ollama_host = "http://127.0.0.1:11434"',
+                    'llm_model = "qwen3:8b"',
+                    'embedding_model = "nomic-embed-text"',
+                    "embedding_dim = 768",
+                    "max_token_size = 8192",
+                    "",
+                    "[slack]",
+                    'client_id = ""',
+                    'client_secret = ""',
+                    'redirect_uri = "http://localhost:8765/slack/oauth/callback"',
+                    'scopes = ["channels:read", "channels:history", "groups:read", "groups:history"]',
+                    "",
+                    "[google]",
+                    'client_id = ""',
+                    'client_secret = ""',
+                    'redirect_uri = "http://localhost:8765/google/oauth/callback"',
+                    'scopes = [',
+                    '  "https://www.googleapis.com/auth/drive.readonly",',
+                    '  "https://www.googleapis.com/auth/gmail.readonly",',
+                    '  "https://www.googleapis.com/auth/calendar.readonly",',
+                    '  "https://www.googleapis.com/auth/spreadsheets.readonly",',
+                    "]",
+                    "",
+                    "[security]",
+                    'token_backend = "file"',
+                    'pii_redaction = "off"',
+                    "",
+                ]
+            ),
+            encoding="utf-8",
+        )
+    ensure_private_file(config)
+    return home
+
+
+def ensure_corpus_layout(corpus_id: str) -> Path:
+    root = corpus_path(corpus_id)
+    for rel in [
+        "bronze/documents",
+        "silver",
+        "gold",
+        "ontology",
+        "store/lightrag",
+        "exports/obsidian",
+        "connectors",
+        "imports",
+    ]:
+        (root / rel).mkdir(parents=True, exist_ok=True)
+    corpus_file = root / "corpus.toml"
+    if not corpus_file.exists():
+        corpus_file.write_text(f'id = "{corpus_id}"\n', encoding="utf-8")
+    write_base_ontology(root / "ontology" / "base.yaml")
+    state_db = root / "state.db"
+    if not state_db.exists():
+        state_db.write_text("", encoding="utf-8")
+    return root

ame/core/state.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+
+class IngestedDocumentState(BaseModel):
+    id: str
+    source_id: str
+    content_hash: str
+
+
+class CorpusState(BaseModel):
+    corpus_id: str
+    last_ingest_at: datetime | None = None
+    last_source_path: str | None = None
+    last_mode: str | None = None
+    documents: list[IngestedDocumentState] = Field(default_factory=list)
+    counts: dict[str, int] = Field(default_factory=dict)
+
+
+class CorpusStateStore:
+    def __init__(self, corpus_root: Path):
+        self.path = corpus_root / "state.db"
+        self.legacy_path = corpus_root / "state.json"
+        self.corpus_id = corpus_root.name
+
+    def read(self) -> CorpusState:
+        path = self.path if self.path.exists() and self.path.read_text(encoding="utf-8").strip() else self.legacy_path
+        if not path.exists():
+            return CorpusState(corpus_id=self.corpus_id)
+        text = path.read_text(encoding="utf-8").strip()
+        if not text:
+            return CorpusState(corpus_id=self.corpus_id)
+        return CorpusState.model_validate_json(text)
+
+    def record_ingest(
+        self,
+        source_path: Path,
+        mode: str,
+        documents: list[IngestedDocumentState],
+        counts: dict[str, int],
+    ) -> CorpusState:
+        state = CorpusState(
+            corpus_id=self.corpus_id,
+            last_ingest_at=datetime.now(timezone.utc),
+            last_source_path=str(source_path),
+            last_mode=mode,
+            documents=documents,
+            counts=counts,
+        )
+        payload = state.model_dump_json(indent=2)
+        self.path.write_text(payload, encoding="utf-8")
+        self.legacy_path.write_text(payload, encoding="utf-8")
+        return state

ame/export/obsidian.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ame.gold.schema import GoldEdge, GoldNode, GoldTimelineEvent
+from ame.gold.store import GoldStore
+
+
+class ObsidianExporter:
+    def __init__(self, gold: GoldStore):
+        self.gold = gold
+
+    def export(self, output_dir: Path) -> int:
+        output_dir.mkdir(parents=True, exist_ok=True)
+        nodes = self.gold.nodes()
+        edges = self.gold.edges()
+        timeline_by_title = {event.title.casefold(): event for event in self.gold.timeline()}
+        count = 0
+        for node in nodes:
+            path = self._node_path(output_dir, node)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            event = timeline_by_title.get(node.name.casefold()) if node.type == "Decision" else None
+            note = self._decision_note(node, event, edges) if event else self._node_note(node, edges)
+            path.write_text(note, encoding="utf-8")
+            count += 1
+        (output_dir / "Index.md").write_text(self._index_note(nodes), encoding="utf-8")
+        count += 1
+        return count
+
+    def _node_note(self, node: GoldNode, edges: list[GoldEdge]) -> str:
+        lines = [
+            "---",
+            f"type: {node.type}",
+            f"canonical_name: {node.canonical_name}",
+            "---",
+            "",
+            f"# {node.name}",
+            "",
+            "## Relations",
+            *self._relation_lines(node, edges),
+            "",
+            "## Sources",
+            *[f"- {source_id}" for source_id in node.source_ids],
+            "",
+        ]
+        return "\n".join(lines)
+
+    def _decision_note(self, node: GoldNode, event: GoldTimelineEvent, edges: list[GoldEdge]) -> str:
+        project = event.project or self._edge_target(node.name, "MADE_IN", edges)
+        tools = [edge.target for edge in edges if edge.source == node.name and edge.relation == "USES"]
+        related_decisions = [edge.target for edge in edges if edge.source == node.name and edge.relation == "SUPERSEDES"]
+        lines = [
+            "---",
+            "type: Decision",
+            f"canonical_name: {node.canonical_name}",
+            f"status: {event.status or 'unknown'}",
+            "---",
+            "",
+            f"# {node.name}",
+            "",
+            f"Status: {event.status or 'unknown'}",
+            f"Project: {self._link('Project', project) if project else 'n/a'}",
+            "",
+            "## Summary",
+            "",
+            event.rationale or node.name,
+            "",
+            "## Related Tools",
+            *[f"- {self._link('Tool', tool)}" for tool in tools],
+            "",
+            "## Sources",
+            *[f"- {source_id}" for source_id in node.source_ids],
+            "",
+            "## Related Decisions",
+            *[f"- {self._link('Decision', title)}" for title in related_decisions],
+            "",
+            "## Relations",
+            *self._relation_lines(node, edges),
+            "",
+        ]
+        return "\n".join(lines)
+
+    def _index_note(self, nodes: list[GoldNode]) -> str:
+        lines = ["# Memory Index", ""]
+        for node_type in sorted({node.type for node in nodes}):
+            lines.extend([f"## {self._folder_name(node_type)}", ""])
+            for node in sorted((node for node in nodes if node.type == node_type), key=lambda row: row.name.casefold()):
+                lines.append(f"- {self._link(node.type, node.name)}")
+            lines.append("")
+        return "\n".join(lines)
+
+    def _node_path(self, output_dir: Path, node: GoldNode) -> Path:
+        return output_dir / self._folder_name(node.type) / f"{self._safe_name(node.name)}.md"
+
+    def _folder_name(self, node_type: str) -> str:
+        return {
+            "Project": "Projects",
+            "Tool": "Tools",
+            "Decision": "Decisions",
+            "Person": "People",
+            "Concept": "Concepts",
+        }.get(node_type, f"{node_type}s")
+
+    def _link(self, node_type: str, name: str) -> str:
+        return f"[[{self._folder_name(node_type)}/{self._safe_name(name)}|{name}]]"
+
+    def _safe_name(self, name: str) -> str:
+        return name.replace("/", "-").replace(":", " -").strip()
+
+    def _edge_target(self, source: str, relation: str, edges: list[GoldEdge]) -> str | None:
+        for edge in edges:
+            if edge.source == source and edge.relation == relation:
+                return edge.target
+        return None
+
+    def _relation_lines(self, node: GoldNode, edges: list[GoldEdge]) -> list[str]:
+        lines: list[str] = []
+        for edge in edges:
+            if edge.source == node.name:
+                lines.append(f"- {edge.relation}: {edge.target}")
+            elif edge.target == node.name:
+                lines.append(f"- {edge.relation}: {edge.source}")
+        return lines or ["- n/a"]