mneme-cli 0.4.0__py3-none-any.whl

mneme/server.py

@@ -0,0 +1,312 @@
+"""
+server.py - Mnemosyne local web UI server.
+
+Usage:
+    cd mneme && python3 server.py
+
+Runs on http://localhost:3141
+"""
+
+import json
+import os
+import sys
+import time
+import traceback
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs, unquote
+
+from .config import (
+    WIKI_DIR,
+    SCHEMA_DIR,
+    LOG_FILE,
+    INDEX_FILE,
+    UI_FILE,
+)
+
+# Lazy import core so memvid errors don't kill startup
+try:
+    from .core import (
+        get_stats,
+        dual_search,
+        check_drift,
+        parse_frontmatter,
+        sync_all_pages,
+    )
+    CORE_OK = True
+except Exception as e:
+    CORE_OK = False
+    CORE_ERROR = str(e)
+
+
+PORT = 3141
+
+
+def _json_response(data):
+    return json.dumps(data, default=str).encode('utf-8')
+
+
+def _error(msg, code=500):
+    return code, _json_response({'error': msg})
+
+
+def handle_stats():
+    if not CORE_OK:
+        return 500, _json_response({'error': CORE_ERROR})
+    try:
+        data = get_stats()
+        return 200, _json_response(data)
+    except Exception as e:
+        return 500, _json_response({'error': str(e), 'trace': traceback.format_exc()})
+
+
+def handle_search(query: str):
+    if not CORE_OK:
+        return 500, _json_response({'error': CORE_ERROR})
+    if not query.strip():
+        return 400, _json_response({'error': 'Empty query'})
+    try:
+        t0 = time.time()
+        results = dual_search(query)
+        elapsed_ms = round((time.time() - t0) * 1000, 1)
+        return 200, _json_response({'results': results, 'count': len(results), 'query': query, 'elapsed_ms': elapsed_ms})
+    except Exception as e:
+        return 500, _json_response({'error': str(e), 'trace': traceback.format_exc()})
+
+
+def handle_drift():
+    if not CORE_OK:
+        return 500, _json_response({'error': CORE_ERROR})
+    try:
+        data = check_drift()
+        return 200, _json_response(data)
+    except Exception as e:
+        return 500, _json_response({'error': str(e), 'trace': traceback.format_exc()})
+
+
+def handle_wiki_list():
+    """Return a nested structure: {client: [page_slug, ...]}"""
+    import glob
+    from pathlib import Path
+    try:
+        pattern = os.path.join(WIKI_DIR, '**', '*.md')
+        all_pages = glob.glob(pattern, recursive=True)
+        tree = {}
+        for page in sorted(all_pages):
+            rel = os.path.relpath(page, WIKI_DIR)
+            parts = Path(rel).parts
+            # Skip _templates
+            if any(p.startswith('_templates') for p in parts):
+                continue
+            client = parts[0] if len(parts) > 1 else '_root'
+            slug = os.path.splitext(rel)[0]  # path without .md
+            if client not in tree:
+                tree[client] = []
+            # Get title from frontmatter if possible
+            title = slug.split('/')[-1]
+            try:
+                with open(page, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                if CORE_OK:
+                    fm, _ = parse_frontmatter(content)
+                    title = fm.get('title', title)
+            except Exception:
+                pass
+            tree[client].append({'slug': slug, 'title': title})
+        return 200, _json_response({'tree': tree})
+    except Exception as e:
+        return 500, _json_response({'error': str(e)})
+
+
+def handle_wiki_page(path_suffix: str):
+    """
+    Read a specific wiki page. path_suffix is like 'demo-retail/sample-proposal'
+    (no .md extension - we add it).
+    """
+    from pathlib import Path
+
+    clean = path_suffix.lstrip('/')
+    if not clean:
+        return 400, _json_response({'error': 'No path given'})
+
+    # Try with and without .md extension, restricted to WIKI_DIR only
+    wiki_base = Path(WIKI_DIR).resolve()
+    candidates = [
+        wiki_base / clean,
+        wiki_base / (clean + '.md'),
+    ]
+    page_path = None
+    for c in candidates:
+        resolved = c.resolve()
+        # Bounds check: must be within WIKI_DIR
+        if not str(resolved).startswith(str(wiki_base)):
+            continue
+        if resolved.is_file() and str(resolved).endswith('.md'):
+            page_path = str(resolved)
+            break
+
+    if not page_path:
+        return 404, _json_response({'error': f'Page not found: {clean}'})
+
+    try:
+        with open(page_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        frontmatter = {}
+        body = content
+        if CORE_OK:
+            frontmatter, body = parse_frontmatter(content)
+        return 200, _json_response({
+            'path': clean,
+            'frontmatter': frontmatter,
+            'body': body,
+            'raw': content,
+        })
+    except Exception as e:
+        return 500, _json_response({'error': str(e)})
+
+
+def handle_entities():
+    path = os.path.join(SCHEMA_DIR, 'entities.json')
+    if not os.path.exists(path):
+        return 404, _json_response({'error': 'entities.json not found'})
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return 200, _json_response(data)
+    except Exception as e:
+        return 500, _json_response({'error': str(e)})
+
+
+def handle_tags():
+    path = os.path.join(SCHEMA_DIR, 'tags.json')
+    if not os.path.exists(path):
+        return 404, _json_response({'error': 'tags.json not found'})
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return 200, _json_response(data)
+    except Exception as e:
+        return 500, _json_response({'error': str(e)})
+
+
+def handle_log():
+    if not os.path.exists(LOG_FILE):
+        return 404, _json_response({'error': 'log.md not found'})
+    try:
+        with open(LOG_FILE, 'r', encoding='utf-8') as f:
+            content = f.read()
+        return 200, _json_response({'content': content})
+    except Exception as e:
+        return 500, _json_response({'error': str(e)})
+
+
+def handle_sync():
+    if not CORE_OK:
+        return 500, _json_response({'error': CORE_ERROR})
+    try:
+        result = sync_all_pages()
+        return 200, _json_response(result)
+    except Exception as e:
+        return 500, _json_response({'error': str(e), 'trace': traceback.format_exc()})
+
+
+class MnemeHandler(BaseHTTPRequestHandler):
+
+    def log_message(self, format, *args):
+        # Custom minimal logging
+        print(f'  {self.command} {self.path} -> {args[1] if len(args) > 1 else "?"}')
+
+    def _send(self, code: int, body: bytes, content_type: str = 'application/json'):
+        self.send_response(code)
+        self.send_header('Content-Type', content_type)
+        self.send_header('Content-Length', str(len(body)))
+        self.send_header('Access-Control-Allow-Origin', 'http://localhost:3141')
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        parsed = urlparse(self.path)
+        path = parsed.path
+        qs = parse_qs(parsed.query)
+
+        # Serve UI
+        if path == '/' or path == '/index.html':
+            if os.path.exists(UI_FILE):
+                with open(UI_FILE, 'rb') as f:
+                    body = f.read()
+                self._send(200, body, 'text/html; charset=utf-8')
+            else:
+                self._send(404, b'<h1>ui.html not found</h1>', 'text/html')
+            return
+
+        # API routing
+        if path == '/api/stats':
+            code, body = handle_stats()
+            self._send(code, body)
+
+        elif path == '/api/search':
+            query = qs.get('q', [''])[0]
+            code, body = handle_search(query)
+            self._send(code, body)
+
+        elif path == '/api/drift':
+            code, body = handle_drift()
+            self._send(code, body)
+
+        elif path == '/api/wiki':
+            code, body = handle_wiki_list()
+            self._send(code, body)
+
+        elif path.startswith('/api/wiki/'):
+            suffix = unquote(path[len('/api/wiki/'):])
+            code, body = handle_wiki_page(suffix)
+            self._send(code, body)
+
+        elif path == '/api/entities':
+            code, body = handle_entities()
+            self._send(code, body)
+
+        elif path == '/api/tags':
+            code, body = handle_tags()
+            self._send(code, body)
+
+        elif path == '/api/log':
+            code, body = handle_log()
+            self._send(code, body)
+
+        else:
+            self._send(404, _json_response({'error': f'Unknown endpoint: {path}'}))
+
+    def do_POST(self):
+        parsed = urlparse(self.path)
+        path = parsed.path
+
+        if path == '/api/sync':
+            code, body = handle_sync()
+            self._send(code, body)
+        else:
+            self._send(404, _json_response({'error': f'Unknown endpoint: {path}'}))
+
+    def do_OPTIONS(self):
+        self.send_response(200)
+        self.send_header('Access-Control-Allow-Origin', 'http://localhost:3141')
+        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+        self.end_headers()
+
+
+def main():
+    server = HTTPServer(('localhost', PORT), MnemeHandler)
+    print(f'Mnemosyne UI running at http://localhost:{PORT}')
+    print('Press Ctrl+C to stop')
+    if not CORE_OK:
+        print(f'[WARNING] core import failed: {CORE_ERROR}')
+        print('[WARNING] Some API endpoints will return errors. Memvid features disabled.')
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print('\nStopped.')
+        server.server_close()
+
+
+if __name__ == '__main__':
+    main()

mneme/templates/workspace/.gitignore

@@ -0,0 +1,9 @@
+memvid/*.mv2
+memvid/per-client/
+memvid/.sync-manifest.json
+exports/
+snapshots/
+.mneme/
+__pycache__/
+*.pyc
+.DS_Store