memex-graph 0.1.0__tar.gz

memex_graph-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Memex Contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

memex_graph-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: memex-graph
+Version: 0.1.0
+Summary: AI-native knowledge graph with decentralized social networking
+Project-URL: Homepage, https://github.com/systemshift/memex
+Project-URL: Repository, https://github.com/systemshift/memex
+Project-URL: Issues, https://github.com/systemshift/memex/issues
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: textual>=0.50
+Requires-Dist: openai>=1.0
+Requires-Dist: httpx>=0.25
+Requires-Dist: rich>=13.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: pydagit>=0.1.0
+Dynamic: license-file

memex_graph-0.1.0/README.md

@@ -0,0 +1,72 @@
+# Memex
+
+AI-native knowledge graph + decentralized social network.
+
+## Install
+
+```bash
+pip install memex
+memex-stack
+```
+
+## What happens
+
+- Downloads knowledge graph server + IPFS automatically
+- Creates your cryptographic identity (Ed25519 DID)
+- Guides you through your first interaction
+
+## What is this
+
+- **Knowledge graph** ([memex-server](https://github.com/systemshift/memex-server)): entities, relationships, raw sources — stored locally in SQLite
+- **Social network** ([dagit](https://github.com/systemshift/dagit)): IPFS-based, Ed25519-signed, no central servers
+- **LLM** (OpenAI): searches your graph, creates nodes, posts to dagit — all through natural language chat
+
+## Prerequisites
+
+- Python 3.10+
+- `OPENAI_API_KEY` environment variable set
+
+```bash
+export OPENAI_API_KEY=sk-...
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────┐
+│              memex TUI              │
+│         (textual chat UI)           │
+├─────────────┬───────────────────────┤
+│  OpenAI API │    function calls     │
+├─────────────┼───────────┬───────────┤
+│ memex-server│   dagit   │   IPFS    │
+│  (SQLite)   │  (Ed25519)│  (kubo)   │
+└─────────────┴───────────┴───────────┘
+```
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OPENAI_API_KEY` | (required) | OpenAI API key |
+| `PORT` | `8080` | memex-server port |
+| `MEMEX_BACKEND` | `sqlite` | Storage backend (`sqlite` or `neo4j`) |
+| `SQLITE_PATH` | `~/.memex/memex.db` | Database path |
+| `MEMEX_SERVER` | (auto-detect) | Path to memex-server binary |
+
+## CLI Flags
+
+```
+memex-stack [options]
+
+  --server-only     Start server without TUI
+  --port PORT       Server port (default: 8080)
+  --backend TYPE    sqlite or neo4j (default: sqlite)
+  --db-path PATH    SQLite database path
+  --skip-ipfs       Skip IPFS daemon setup
+  --skip-download   Don't auto-download binaries
+```
+
+## License
+
+BSD 3-Clause. See [LICENSE](LICENSE).

memex_graph-0.1.0/memex/__init__.py

@@ -0,0 +1,14 @@
+"""Memex - AI-native knowledge graph with decentralized social networking."""
+
+__version__ = "0.1.0"
+
+from .app import MemexApp
+
+
+def main():
+    """Entry point for memex command."""
+    app = MemexApp()
+    app.run()
+
+
+__all__ = ["main", "MemexApp"]

memex_graph-0.1.0/memex/app.py

@@ -0,0 +1,181 @@
+"""Memex Application."""
+
+from textual.app import App, ComposeResult
+from textual.widgets import Input, Footer, Header
+from textual.containers import Container
+from textual.binding import Binding
+
+from .chat import ChatPanel, ChatEngine
+
+
+class MemexApp(App):
+    """Interactive interface for memex-server and dagit."""
+
+    CSS = """
+    Screen {
+        layout: grid;
+        grid-size: 1;
+        grid-rows: 1fr auto;
+    }
+
+    #chat-container {
+        height: 100%;
+        border: solid $primary;
+        padding: 1;
+    }
+
+    #chat-log {
+        height: 100%;
+        scrollbar-gutter: stable;
+    }
+
+    #input-container {
+        height: auto;
+        padding: 1;
+    }
+
+    #input {
+        dock: bottom;
+    }
+
+    Footer {
+        height: auto;
+    }
+    """
+
+    BINDINGS = [
+        Binding("ctrl+c", "quit", "Quit"),
+        Binding("ctrl+l", "clear", "Clear"),
+        Binding("escape", "focus_input", "Focus Input", show=False),
+    ]
+
+    TITLE = "Memex"
+
+    def __init__(self, first_run: bool = False):
+        super().__init__()
+        self.first_run = first_run
+        self.chat_engine = ChatEngine(first_run=first_run)
+        self._current_response = ""
+
+    def compose(self) -> ComposeResult:
+        """Create the UI layout."""
+        yield Header()
+        with Container(id="chat-container"):
+            yield ChatPanel(id="chat-log")
+        with Container(id="input-container"):
+            yield Input(placeholder="Ask anything... (Ctrl+C to quit)", id="input")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Focus input on start."""
+        self.query_one("#input", Input).focus()
+        chat = self.query_one("#chat-log", ChatPanel)
+
+        if self.first_run:
+            chat.add_system_message("Welcome to Memex — setting things up...")
+            self.run_worker(self._auto_greet())
+        else:
+            chat.add_system_message(
+                "Welcome to Memex. Ask questions about your knowledge graph or dagit network."
+            )
+            chat.add_system_message('Type "help" for commands, Ctrl+C to quit.')
+
+    async def _auto_greet(self) -> None:
+        """Send initial greeting on first run so the LLM speaks first."""
+        chat = self.query_one("#chat-log", ChatPanel)
+        chat.start_assistant_response()
+        self._current_response = ""
+
+        async def on_text(text: str) -> None:
+            self._current_response += text
+            chat.add_assistant_text(text)
+
+        async def on_tool(tool_name: str) -> None:
+            chat.add_tool_indicator(tool_name)
+
+        try:
+            await self.chat_engine.send(
+                "I just installed memex. Help me get started.", on_text, on_tool
+            )
+        except Exception as e:
+            chat.add_error(str(e))
+
+        if self._current_response and not self._current_response.endswith("\n"):
+            chat.write("")
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle user input."""
+        user_input = event.value.strip()
+        if not user_input:
+            return
+
+        # Clear input
+        input_widget = self.query_one("#input", Input)
+        input_widget.value = ""
+
+        chat = self.query_one("#chat-log", ChatPanel)
+
+        # Handle special commands
+        if user_input.lower() in ("exit", "quit"):
+            self.exit()
+            return
+
+        if user_input.lower() == "clear":
+            self.action_clear()
+            return
+
+        if user_input.lower() == "help":
+            self._show_help(chat)
+            return
+
+        # Show user message
+        chat.add_user_message(user_input)
+
+        # Start assistant response
+        chat.start_assistant_response()
+        self._current_response = ""
+
+        # Stream response
+        async def on_text(text: str) -> None:
+            self._current_response += text
+            chat.add_assistant_text(text)
+
+        async def on_tool(tool_name: str) -> None:
+            chat.add_tool_indicator(tool_name)
+
+        try:
+            await self.chat_engine.send(user_input, on_text, on_tool)
+        except Exception as e:
+            chat.add_error(str(e))
+
+        # Ensure we end on a new line
+        if self._current_response and not self._current_response.endswith("\n"):
+            chat.write("")
+
+    def _show_help(self, chat: ChatPanel) -> None:
+        """Show help message."""
+        chat.add_system_message("Commands:")
+        chat.add_system_message("  help  - Show this help")
+        chat.add_system_message("  clear - Clear chat history")
+        chat.add_system_message("  exit  - Quit the application")
+        chat.add_system_message("")
+        chat.add_system_message("Examples:")
+        chat.add_system_message('  "search for notes about topic"')
+        chat.add_system_message('  "what\'s my dagit identity"')
+        chat.add_system_message('  "save this as a note: <your content>"')
+        chat.add_system_message('  "post to dagit: <your message>"')
+
+    def action_clear(self) -> None:
+        """Clear chat history."""
+        self.chat_engine.clear()
+        chat = self.query_one("#chat-log", ChatPanel)
+        chat.clear()
+        chat.add_system_message("Chat cleared.")
+
+    def action_focus_input(self) -> None:
+        """Focus the input field."""
+        self.query_one("#input", Input).focus()
+
+    def action_quit(self) -> None:
+        """Quit the application."""
+        self.exit()

memex_graph-0.1.0/memex/binaries.py

@@ -0,0 +1,236 @@
+"""Auto-download and cache external binaries in ~/.memex/bin/."""
+
+import os
+import platform
+import shutil
+import stat
+import tarfile
+import zipfile
+from pathlib import Path
+
+import httpx
+
+BIN_DIR = Path.home() / ".memex" / "bin"
+
+MEMEX_SERVER_VERSION = "v0.1.0"
+KUBO_VERSION = "v0.32.1"
+
+MEMEX_SERVER_REPO = "systemshift/memex-server"
+KUBO_REPO = "ipfs/kubo"
+
+
+def _detect_platform() -> tuple[str, str]:
+    """Detect OS and architecture.
+
+    Returns:
+        (os_name, arch) normalized for download URLs.
+    """
+    system = platform.system()
+    machine = platform.machine().lower()
+
+    if system == "Linux":
+        os_name = "linux"
+    elif system == "Darwin":
+        os_name = "darwin"
+    else:
+        raise RuntimeError(f"Unsupported OS: {system}. Only Linux and macOS are supported.")
+
+    if machine in ("x86_64", "amd64"):
+        arch = "amd64"
+    elif machine in ("aarch64", "arm64"):
+        arch = "arm64"
+    else:
+        raise RuntimeError(f"Unsupported architecture: {machine}. Only x86_64 and arm64 are supported.")
+
+    return os_name, arch
+
+
+def _download_file(url: str, dest: Path, label: str) -> None:
+    """Download a file with progress output.
+
+    Args:
+        url: URL to download from.
+        dest: Destination path.
+        label: Human-readable label for progress output.
+    """
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    print(f"  Downloading {label}...")
+    print(f"  {url}")
+
+    with httpx.stream("GET", url, follow_redirects=True, timeout=120) as resp:
+        if resp.status_code == 404:
+            raise RuntimeError(
+                f"Download not found (404): {url}\n"
+                f"  The release may not be published yet."
+            )
+        resp.raise_for_status()
+
+        total = int(resp.headers.get("content-length", 0))
+        downloaded = 0
+
+        with open(dest, "wb") as f:
+            for chunk in resp.iter_bytes(chunk_size=65536):
+                f.write(chunk)
+                downloaded += len(chunk)
+                if total:
+                    pct = downloaded * 100 // total
+                    mb = downloaded / (1024 * 1024)
+                    total_mb = total / (1024 * 1024)
+                    print(f"\r  {mb:.1f}/{total_mb:.1f} MB ({pct}%)", end="", flush=True)
+
+    if total:
+        print()  # newline after progress
+    print(f"  Downloaded {label}")
+
+
+def _extract_binary(archive: Path, binary_name: str, dest: Path) -> None:
+    """Extract a single binary from an archive.
+
+    Args:
+        archive: Path to tar.gz or zip archive.
+        binary_name: Path of the binary within the archive (e.g. "kubo/ipfs").
+        dest: Destination path for the extracted binary.
+    """
+    dest.parent.mkdir(parents=True, exist_ok=True)
+
+    if archive.name.endswith(".tar.gz") or archive.name.endswith(".tgz"):
+        with tarfile.open(archive, "r:gz") as tf:
+            # Look for the binary in the archive
+            for member in tf.getmembers():
+                if member.name == binary_name or member.name.endswith(f"/{binary_name}"):
+                    # Extract to temp location then move
+                    member.name = dest.name
+                    tf.extract(member, dest.parent)
+                    break
+            else:
+                # Try just the basename
+                basename = Path(binary_name).name
+                for member in tf.getmembers():
+                    if Path(member.name).name == basename:
+                        member.name = dest.name
+                        tf.extract(member, dest.parent)
+                        break
+                else:
+                    names = [m.name for m in tf.getmembers()]
+                    raise RuntimeError(
+                        f"Binary '{binary_name}' not found in archive. Contents: {names}"
+                    )
+
+    elif archive.name.endswith(".zip"):
+        with zipfile.ZipFile(archive) as zf:
+            for name in zf.namelist():
+                if name == binary_name or name.endswith(f"/{binary_name}"):
+                    data = zf.read(name)
+                    dest.write_bytes(data)
+                    break
+            else:
+                basename = Path(binary_name).name
+                for name in zf.namelist():
+                    if Path(name).name == basename:
+                        data = zf.read(name)
+                        dest.write_bytes(data)
+                        break
+                else:
+                    raise RuntimeError(
+                        f"Binary '{binary_name}' not found in archive. Contents: {zf.namelist()}"
+                    )
+    else:
+        raise RuntimeError(f"Unknown archive format: {archive.name}")
+
+    # Make executable
+    dest.chmod(dest.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+    # Clean up archive
+    archive.unlink()
+
+
+def ensure_memex_server() -> str:
+    """Ensure memex-server binary is available.
+
+    Checks in order:
+    1. MEMEX_SERVER environment variable
+    2. System PATH
+    3. ~/.memex/bin/ cache
+    4. Downloads from GitHub releases
+
+    Returns:
+        Path to the memex-server binary.
+    """
+    # Check env var
+    if server := os.environ.get("MEMEX_SERVER"):
+        if Path(server).is_file():
+            return server
+
+    # Check PATH
+    if path_bin := shutil.which("memex-server"):
+        return path_bin
+
+    # Check cache
+    cached = BIN_DIR / "memex-server"
+    if cached.is_file():
+        return str(cached)
+
+    # Download
+    print("\033[0;32m[memex]\033[0m memex-server not found, downloading...")
+    try:
+        os_name, arch = _detect_platform()
+
+        # memex-server uses Linux/Darwin and x86_64/arm64
+        os_label = "Linux" if os_name == "linux" else "Darwin"
+        arch_label = "x86_64" if arch == "amd64" else "arm64"
+
+        filename = f"memex_{os_label}_{arch_label}.tar.gz"
+        url = f"https://github.com/{MEMEX_SERVER_REPO}/releases/download/{MEMEX_SERVER_VERSION}/{filename}"
+
+        archive = BIN_DIR / filename
+        _download_file(url, archive, "memex-server")
+        _extract_binary(archive, "memex-server", cached)
+
+        print(f"\033[0;32m[memex]\033[0m memex-server installed to {cached}")
+        return str(cached)
+
+    except Exception as e:
+        print(f"\033[0;31m[memex]\033[0m Failed to download memex-server: {e}")
+        print(f"\033[0;31m[memex]\033[0m Install manually from: https://github.com/{MEMEX_SERVER_REPO}/releases")
+        raise SystemExit(1)
+
+
+def ensure_ipfs() -> str:
+    """Ensure IPFS (kubo) binary is available.
+
+    Checks in order:
+    1. System PATH
+    2. ~/.memex/bin/ cache
+    3. Downloads from GitHub releases
+
+    Returns:
+        Path to the ipfs binary.
+    """
+    # Check PATH
+    if path_bin := shutil.which("ipfs"):
+        return path_bin
+
+    # Check cache
+    cached = BIN_DIR / "ipfs"
+    if cached.is_file():
+        return str(cached)
+
+    # Download
+    print("\033[0;32m[memex]\033[0m IPFS not found, downloading kubo...")
+    try:
+        os_name, arch = _detect_platform()
+
+        filename = f"kubo_{KUBO_VERSION}_{os_name}-{arch}.tar.gz"
+        url = f"https://github.com/{KUBO_REPO}/releases/download/{KUBO_VERSION}/{filename}"
+
+        archive = BIN_DIR / filename
+        _download_file(url, archive, "IPFS (kubo)")
+        _extract_binary(archive, "kubo/ipfs", cached)
+
+        print(f"\033[0;32m[memex]\033[0m IPFS installed to {cached}")
+        return str(cached)
+
+    except Exception as e:
+        print(f"\033[0;31m[memex]\033[0m Failed to download IPFS: {e}")
+        print(f"\033[0;31m[memex]\033[0m Install manually from: https://docs.ipfs.tech/install/")
+        raise SystemExit(1)