echomind-memory 1.1.5__py3-none-any.whl

echomind/adapters/http_api.py

@@ -0,0 +1,323 @@
+# echomind_memory — FastAPI Service entry point (v2, SQLite)
+# Based on upstream update: github.com/jasonatgit/echomind_memory.skill
+
+import json
+import os
+import sys
+from typing import Any, Dict, List, Optional
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import APIKeyHeader
+from pydantic import BaseModel
+import logging
+import uvicorn
+
+from echomind.core.memory_agent import MainMemoryAgent
+from echomind.core._reflective_version import get_echomind_version
+from echomind.core.config_manager import get_config_manager
+
+# ── Init ──
+memory_agent = MainMemoryAgent()
+
+cfg = get_config_manager().get_section("server")
+
+# ── API Key Auth ──
+API_KEY_NAME = "X-API-Key"
+api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
+
+
+def verify_api_key(api_key: str = Depends(api_key_header)):
+    expected = cfg.get("api_key", "")
+    if not expected:
+        return ""  # no key configured — allow all (backward compat)
+    if api_key and api_key == expected:
+        return api_key
+    raise HTTPException(status_code=403, detail="Invalid or missing API key")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    memory_agent.enable_persistence()
+    yield
+    memory_agent.disable_persistence()
+
+
+app = FastAPI(title="EchoMind Memory", version=get_echomind_version(), lifespan=lifespan)
+cors_origins = cfg.get("cors_origins", ["http://localhost:8005"])
+app.add_middleware(CORSMiddleware, allow_origins=cors_origins, allow_methods=["GET", "POST"], allow_headers=["Content-Type", "X-API-Key"])
+
+
+# ── Health ──
+@app.get("/health")
+async def health():
+    return {"status": "ok", "storage": "sqlite",
+            "db": os.path.basename(str(memory_agent.db.db_path)),
+            "version": get_echomind_version()}
+
+
+# ── Models ──
+class RetrieveRequest(BaseModel):
+    user_id: str
+    platform: Optional[str] = None
+    query: str
+    task_id: Optional[str] = None
+    max_results: int = 5
+
+class ContextMessage(BaseModel):
+    role: str
+    content: str
+
+class StoreRequest(BaseModel):
+    user_id: str
+    platform: Optional[str] = None
+    task_id: str
+    title: Optional[str] = None
+    context: List[ContextMessage]
+    task_status: str
+    success: bool = False
+    experience_summary: Optional[str] = None
+
+class FeedbackRequest(BaseModel):
+    user_id: str
+    task_id: str
+    feedback: str
+    retrieved_memories: List[Dict[str, Any]]
+
+class SyncCodeRequest(BaseModel):
+    project_root: str
+    user_id: str
+
+class ResearchPaperRequest(BaseModel):
+    title: str
+    authors: Optional[List[str]] = None
+    year: Optional[int] = None
+    journal: Optional[str] = None
+    abstract: str = ""
+    keywords: Optional[List[str]] = None
+    domain: str = "general"
+    paper_type: str = "theory"
+    key_points: Optional[List[str]] = None
+    importance_score: float = 0.5
+
+class ResearchNoteRequest(BaseModel):
+    user_id: str
+    topic: str
+    content: str
+    linked_papers: List[str] = []
+    tags: List[str] = []
+
+
+class ReflectRequest(BaseModel):
+    """Reflection endpoint — build prompt or process result"""
+    user_id: str
+    platform: Optional[str] = "http"
+    count: int = 8
+    record_ids: Optional[List[str]] = None
+    llm_response: Optional[str] = None
+
+
+# ── Error handler (v1.2.0: avoid leaking internal details) ──
+logger = logging.getLogger("EchoMind.API")
+
+EXCEPTION_RESPONSE = {"status": "error", "detail": "Internal server error"}
+
+
+async def _safe_exception(e: Exception, context: str = "") -> dict:
+    logger.error(f"{context}: {e}", exc_info=True)
+    return EXCEPTION_RESPONSE
+
+
+# ── Routes ──
+@app.post("/api/memory/retrieve")
+async def api_retrieve(req: RetrieveRequest, auth=Depends(verify_api_key)):
+    try:
+        result = memory_agent.retrieve_for_task(req.query, req.user_id, req.task_id, platform=req.platform)
+        working = [
+            {"source": m.source, "content": m.content,
+             "importance": m.importance, "metadata": m.metadata}
+            for m in result["working_memory"][:req.max_results]
+        ]
+        confidence = (
+            sum(m.importance for m in result["working_memory"])
+            / max(len(result["working_memory"]), 1)
+        )
+        return {
+            "working_memory": working,
+            "experience_memory": result.get("raw_memory_sources", {}).get("experience", []),
+            "knowledge_memory": result.get("raw_memory_sources", {}).get("knowledge", []),
+            "confidence_score": float(confidence),
+            "used_weights": memory_agent.rl_optimizer.get_current_weights(),
+            "feedback_requested": result.get("feedback_request", False),
+            "raw_memory_sources": result.get("raw_memory_sources", {}),
+            "task_features": result.get("task_features", {}),
+        }
+    except Exception as e:
+        return {
+            "working_memory": [], "raw_memory_sources": {},
+            "experience_memory": [], "knowledge_memory": [],
+            "confidence_score": 0.0,
+            "used_weights": {}, "feedback_requested": False, "error": str(e),
+        }
+
+@app.post("/api/memory/store")
+async def api_store(req: StoreRequest, auth=Depends(verify_api_key)):
+    try:
+        memory_agent.store(
+            req.user_id, req.task_id,
+            [{"role": m.role, "content": m.content} for m in req.context],
+            req.task_status, req.success, req.experience_summary,
+            platform=req.platform, title=req.title,
+        )
+        return {"status": "stored", "user_id": req.user_id, "task_id": req.task_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/memory/search-sessions")
+async def search_sessions(q: str = "", user_id: str = None, project: str = None, limit: int = 5):
+    if not memory_agent or not memory_agent.is_persistence_enabled():
+        return {"results": [], "message": "Persistence is not enabled"}
+    try:
+        results = memory_agent.db.search_transcripts(q, user_id, project, limit)
+        return {"results": results, "count": len(results)}
+    except Exception as e:
+        return {"results": [], "error": str(e)}
+
+@app.post("/api/memory/feedback")
+async def api_feedback(req: FeedbackRequest, auth=Depends(verify_api_key)):
+    try:
+        memory_agent.record_feedback(req.user_id, req.task_id, req.feedback, req.retrieved_memories)
+        return {"status": "feedback_received", "user_id": req.user_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/memory/sync-code")
+async def api_sync_code(req: SyncCodeRequest, auth=Depends(verify_api_key)):
+    try:
+        memory_agent.sync_to_code_project(req.project_root, req.user_id)
+        return {"status": "synced", "path": f"{req.project_root}/.echomind"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/research/paper")
+async def api_add_paper(req: ResearchPaperRequest, auth=Depends(verify_api_key)):
+    try:
+        paper_id = memory_agent.add_research_paper(
+            title=req.title, authors=req.authors, year=req.year,
+            journal=req.journal, abstract=req.abstract, keywords=req.keywords,
+            domain=req.domain, paper_type=req.paper_type,
+            key_points=req.key_points, importance_score=req.importance_score)
+        return {"status": "stored", "paper_id": paper_id, "title": req.title}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/research/note")
+async def api_add_note(req: ResearchNoteRequest, auth=Depends(verify_api_key)):
+    try:
+        note_id = memory_agent.add_research_note(
+            user_id=req.user_id, topic=req.topic, content=req.content,
+            linked_papers=req.linked_papers, tags=req.tags)
+        return {"status": "stored", "note_id": note_id, "topic": req.topic}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ── Reflection (v1.1.0) ──
+@app.post("/api/reflect")
+async def api_reflect(req: ReflectRequest, auth=Depends(verify_api_key)):
+    """
+    Two-phase reflection endpoint:
+    - llm_response=None → returns prompt for caller to process (Path B)
+    - llm_response=... → parses and writes back (Path A / process)
+    """
+    if req.llm_response is None:
+        records = memory_agent.get_recent_episodic(req.user_id, req.count)
+        prompt, record_ids = memory_agent.reflective.build_prompt(
+            records, req.user_id, req.platform or "http"
+        )
+        return {
+            "phase": "build",
+            "prompt": prompt,
+            "record_ids": record_ids,
+            "record_count": len(records),
+        }
+    else:
+        # Fetch full records (not just IDs) for process_result
+        full_records = memory_agent.get_recent_episodic(req.user_id, req.count)
+        # Filter to requested IDs (if specified)
+        if req.record_ids:
+            id_set = set(req.record_ids)
+            records = [r for r in full_records if r.get("id") in id_set]
+            if not records:
+                # Records may have been evicted; use placeholders
+                records = [{"id": rid, "content": "", "text": ""} for rid in id_set]
+        else:
+            records = full_records
+        output = memory_agent.reflective.process_result(
+            raw_response=req.llm_response,
+            records=records,
+            user_id=req.user_id,
+            platform=req.platform or "http",
+        )
+        if output is None:
+            raise HTTPException(
+                status_code=400,
+                detail="Reflection failed: parse error or confidence too low",
+            )
+        return {
+            "phase": "done",
+            "insights": len(output.key_insights),
+            "preferences": len(output.user_preferences),
+            "rules": len(output.procedural_rules),
+            "knowledge": len(output.new_knowledge),
+            "confidence": output.confidence,
+        }
+
+
+# ── Config (v1.1.0) ──
+class ConfigUpdateRequest(BaseModel):
+    section: str
+    key: str
+    value: Any
+
+
+@app.get("/api/config")
+async def api_get_config(auth=Depends(verify_api_key)):
+    cfg = get_config_manager()
+    return {
+        "config_path": cfg.config_path,
+        "sections": {
+            "rl": cfg.get_section("rl"),
+            "reflection": cfg.get_section("reflection"),
+            "retrieval": cfg.get_section("retrieval"),
+            "inference": cfg.get_section("inference"),
+            "llm": {k: v for k, v in cfg.get_section("llm").items() if k != "api_key"},
+            "server": cfg.get_section("server"),
+        }
+    }
+
+
+@app.post("/api/config/parameter")
+async def api_set_config_param(req: ConfigUpdateRequest, auth=Depends(verify_api_key)):
+    cfg = get_config_manager()
+    key_path = f"{req.section}.{req.key}"
+    cfg.set_runtime(key_path, req.value)
+    return {"status": "ok", "key": key_path, "value": req.value}
+
+
+@app.post("/api/config/reload")
+async def api_reload_config(auth=Depends(verify_api_key)):
+    cfg = get_config_manager()
+    cfg.reload()
+    return {"status": "reloaded", "config_path": cfg.config_path}
+
+
+# ── Entry ──
+if __name__ == "__main__":
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else cfg.get("port", 8005)
+    host = cfg.get("host", "127.0.0.1")
+    print(f"EchoMind Memory v{get_echomind_version()} — HTTP API Mode")
+    print(f"  Endpoint: http://{host}:{port}")
+    print(f"  Docs:     http://{host}:{port}/docs")
+    uvicorn.run(app, host=host, port=port, log_level="info")

echomind/code_format/cli.py

@@ -0,0 +1,74 @@
+import json
+import sys
+import os
+from datetime import datetime, timezone
+
+# Support both direct run (`python cli.py`) and package import
+_h = os.path.dirname(os.path.abspath(__file__))   # .../echomind/code_format
+_h = os.path.dirname(_h)                          # .../echomind
+_h = os.path.dirname(_h)                          # src/
+if _h not in sys.path:
+    sys.path.insert(0, _h)
+from echomind.core.memory_agent import MainMemoryAgent
+
+
+def main():
+    if len(sys.argv) < 4:
+        print("Usage: echomind-cli [read|write] <user_id> <project_id> [file_path]")
+        sys.exit(1)
+
+    action = sys.argv[1]
+    user_id = sys.argv[2]
+    project_id = sys.argv[3]
+    agent = MainMemoryAgent()
+    agent.enable_persistence()
+
+    if action == "read":
+        user_mem = agent.user_agent.get(user_id)
+        exp_mem = agent.experience_agent.find_similar_tasks(
+            task_context=f"code style: {user_mem.get('preferences', {}).get('code_style', 'standard')}",
+            task_type="code_review",
+            min_success_rate=0.6,
+        )
+
+        result = {
+            "user_id": user_id,
+            "project_id": project_id,
+            "preferences": user_mem.get("preferences", {}),
+            "experience": [
+                {
+                    "action": "fix",
+                    "location": "unknown",
+                    "summary": m["summary"],
+                    "success": m["success"],
+                    "created_at": datetime.now(timezone.utc).isoformat(),
+                }
+                for m in exp_mem
+            ],
+            "updated_at": datetime.now(timezone.utc).isoformat(),
+        }
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+
+    elif action == "write":
+        data = json.load(sys.stdin)
+        if "preferences" in data:
+            agent.user_agent.update(
+                user_id, "preferences", data["preferences"], source="code_cli"
+            )
+        if "experience" in data:
+            for exp in data["experience"]:
+                agent.experience_agent.store_experience(
+                    user_id=user_id,
+                    task_id=f"code_{exp['location']}",
+                    task_type="code_review",
+                    success=exp["success"],
+                    steps=[exp["summary"]],
+                    summary=exp["summary"],
+                )
+        print(json.dumps({"status": "written"}))
+
+    agent.disable_persistence()
+
+
+if __name__ == "__main__":
+    main()

echomind/code_format/memory.schema.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "EchoMind Code Memory",
+  "type": "object",
+  "properties": {
+    "user_id": { "type": "string" },
+    "project_id": { "type": "string" },
+    "preferences": {
+      "type": "object",
+      "properties": {
+        "code_style": { "enum": ["concise", "detailed", "standard"] },
+        "max_line_length": { "type": "integer", "minimum": 70, "maximum": 120 },
+        "comment_style": { "enum": ["docstring", "inline", "none"] }
+      }
+    },
+    "experience": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "action": { "enum": ["fix", "refactor", "add", "remove"] },
+          "location": { "type": "string" },
+          "summary": { "type": "string" },
+          "success": { "type": "boolean" },
+          "created_at": { "type": "string", "format": "date-time" }
+        },
+        "required": ["action", "location", "summary", "success"]
+      }
+    },
+    "updated_at": { "type": "string", "format": "date-time" }
+  },
+  "required": ["user_id", "project_id", "preferences", "experience", "updated_at"]
+}

echomind/core/__init__.py

@@ -0,0 +1,25 @@
+# EchoMind Memory — Core module
+# Platform-agnostic memory engine（6 Agent + RL + SQLite）
+# Called by adapters, not dependent on any web framework
+
+from .memory_agent import (
+    MainMemoryAgent,
+    ContextMemoryAgent,
+    TaskMemoryAgent,
+    UserMemoryAgent,
+    KnowledgeMemoryAgent,
+    ExperienceMemoryAgent,
+    ResearchMemoryAgent,
+    MemoryRecord,
+)
+
+__all__ = [
+    "MainMemoryAgent",
+    "ContextMemoryAgent",
+    "TaskMemoryAgent",
+    "UserMemoryAgent",
+    "KnowledgeMemoryAgent",
+    "ExperienceMemoryAgent",
+    "ResearchMemoryAgent",
+    "MemoryRecord",
+]

echomind/core/_reflective_fallback.py

@@ -0,0 +1,200 @@
+# core/_reflective_fallback.py
+# Pure-function safe fallback: Return empty when unavailable / Basic keyword extraction
+
+import re
+from collections import Counter
+
+
+def _build_prompt(context, config):
+    return ""
+
+
+def _load_few_shot():
+    return []
+
+
+def _get_extra_params():
+    return []
+
+
+def _parse_result(raw):
+    return raw
+
+
+# ── Keyword fallback: provider=none extract high-frequency words as basic reflection ──
+
+_STOPWORDS_EN = {
+    "the", "is", "are", "a", "an", "and", "or", "but", "in", "on",
+    "to", "for", "of", "with", "at", "from", "by", "that", "this",
+    "it", "as", "be", "was", "has", "have", "had", "not", "no",
+    "if", "so", "we", "you", "he", "she", "they", "i", "my", "me",
+    "your", "his", "her", "our", "their", "can", "will", "just",
+    "what", "when", "where", "which", "who", "how", "all", "also",
+    "do", "does", "did", "been", "being", "would", "could", "should",
+    "more", "some", "any", "only", "very", "about", "than", "then",
+    "now", "other", "into", "its", "these", "those", "each", "every",
+    "over", "much", "such", "after", "before", "between", "through",
+    "during", "may", "might", "must", "shall", "need", "want", "know",
+    "think", "thing", "well", "use", "see", "make", "get", "way",
+    "take", "come", "give", "find", "tell", "ask", "try", "leave",
+    "call", "keep", "let", "seem", "help", "show", "mean", "set",
+    "put", "move", "work", "old", "long", "even", "back", "still",
+    "here", "there", "up", "out", "new", "like", "good", "great",
+    "right", "same", "while", "really", "again", "go", "first",
+}
+
+_STOPWORDS_ZH = {
+    "", "了", "is", "我", "在", "有", "和", "就", "不", "人",
+    "都", "一", "a", "上", "也", "很", "到", "说", "要", "去",
+    "你", "会", "着", "no", "看", "好", "itself", "这", "他", "她",
+    "它", "们", "那", "些", "what", "how", "how to", "can", "this",
+    "that", "because", "therefore", "but", "although", "If", "or", "already",
+    "maybe", "should", "must", "think", "know", "", "一种", "some",
+    "not", "or", "here", "there", "this way", "that way", "when", "after",
+    "before", "then", "now", "comparison", "need", "use", "issue", "work",
+    "content", "perform", "system", "method", "passed", "implement", "Completed", "process",
+    "situation", "relationship", "part", "result", "start", "end", "Handle", "manage",
+    "support", "development", "test", "check", "confirm", "maintain", "maintenance", "Update",
+    "related", "consider", "suggestion", "note", "indeed", "really", "very", "many",
+}
+
+
+def _extract_keywords(records, top_k=10):
+    """Extract top-K frequent words with TF-IDF weighting from records.
+    Handles mixed EN/ZH text: trigrams for EN (v1.1.0), bigrams for ZH.
+    No jieba dependency.
+    """
+    # Collect all text
+    texts = []
+    for r in records:
+        if isinstance(r, dict):
+            texts.append(r.get("content", "") or r.get("text", "") or "")
+        elif isinstance(r, str):
+            texts.append(r)
+    all_text = " ".join(texts).strip()
+    if not all_text:
+        return []
+
+    tokens = []
+
+    # EN words: regex word boundaries (2+ chars)
+    en_words = re.findall(r'\b[a-zA-Z]{2,}\b', all_text.lower())
+    tokens.extend(w for w in en_words if w not in _STOPWORDS_EN)
+
+    # EN trigrams (3-word phrases) for richer context
+    en_filtered = [w for w in en_words if w not in _STOPWORDS_EN]
+    for i in range(len(en_filtered) - 2):
+        trigram = "_".join(en_filtered[i:i+3])
+        tokens.append(trigram)
+
+    # ZH "words": 2-4 char bigrams (no jieba)
+    zh_chars = re.findall(r'[\u4e00-\u9fff]+', all_text)
+    for segment in zh_chars:
+        if len(segment) >= 2:
+            for i in range(len(segment) - 1):
+                bigram = segment[i:i+2]
+                if bigram not in _STOPWORDS_ZH:
+                    tokens.append(bigram)
+            # Also add 3-char trigrams for specificity
+            if len(segment) >= 3:
+                for i in range(len(segment) - 2):
+                    trigram = segment[i:i+3]
+                    if trigram not in _STOPWORDS_ZH:
+                        tokens.append(trigram)
+
+    # TF-IDF: normalize by document frequency (approximate IDF)
+    counter = Counter(tokens)
+    total = sum(counter.values())
+    if total > 0:
+        scored = {w: c/total for w, c in counter.items()}
+        sorted_words = sorted(scored.items(), key=lambda x: x[1], reverse=True)
+        return [word for word, _ in sorted_words[:top_k]]
+    return [word for word, _ in counter.most_common(top_k)]
+
+
+def _reflect_records(
+    records, user_id, platform, llm_fn, config, store, memory
+):
+    """Basic keyword-based reflection when the compiled extension is unavailable.
+
+    Only activates when provider is explicitly 'none' (no LLM available).
+    Extracts top frequent keywords as key_insights with low confidence.
+    """
+    provider = ""
+    if isinstance(config, dict):
+        provider = config.get("provider", "")
+        if not provider:
+            # Check nested llm config (from ConfigManager path)
+            llm_cfg = config.get("llm", {})
+            if isinstance(llm_cfg, dict):
+                provider = llm_cfg.get("provider", "")
+
+    if provider != "none":
+        return None
+
+    keywords = _extract_keywords(records)
+    if not keywords:
+        return None
+
+    # P1-4: typed output — separate insights, preferences, rules, knowledge
+    output = {
+        "key_insights": keywords[:10],
+        "preferences": {},
+        "rules": [],
+        "knowledge": [],
+        "experience": [],
+        "procedural_rules": [],
+        "confidence": 0.3,
+        "source": "fallback_keyword",
+    }
+
+    # Try to classify keywords into categories
+    pref_kw = {"like", "prefer", "want", "need", "okay", "good", "like",
+               "preference", "style", "format", "language", "language",
+               "habit", "usually", "always", "never", "avoid", "不", "like",
+               "preferences", "habits", "always", "never", "avoid"}
+    rule_kw = {"rule", "must", "should", "always", "never", "require",
+               "rule", "must", "require", "rule", "must", "should"}
+    
+    for kw in keywords:
+        kw_lower = kw.lower()
+        if any(p in kw_lower or p in kw for p in pref_kw):
+            output["preferences"][kw] = "keyword"
+        elif any(r in kw_lower or r in kw for r in rule_kw):
+            output["rules"].append(kw)
+        else:
+            output["knowledge"].append({
+                "content": kw, "domain": "general", "source": "fallback"
+            })
+
+    return output
+
+
+def _process_reflection(
+    raw_response, records, user_id, platform, config, store, memory_agent
+):
+    return None
+
+
+def _prepare_reflection_context(records):
+    return ""
+
+
+def _merge_semantic(output, knowledge_agent):
+    pass
+
+
+def _merge_procedural(output, knowledge_agent):
+    pass
+
+
+def _merge_user_preferences(output, user_id, platform, user_agent):
+    pass
+
+
+def _update_rl_weights(output, memory_agent):
+    pass
+
+
+def _save_reflection(record, store, memory_agent):
+    pass

echomind/core/_reflective_version.py

@@ -0,0 +1,19 @@
+# core/_reflective_version.py — Version detection
+
+
+__all__ = ["get_echomind_version"]
+
+ECHOMIND_VERSION = "1.1.5"
+
+
+def get_echomind_version() -> str:
+    return ECHOMIND_VERSION
+
+
+def _engine_available() -> bool:
+    try:
+        import importlib
+        mod = importlib.import_module("echomind.core._reflective_core")
+        return mod is not None
+    except (ImportError, ModuleNotFoundError):
+        return False