memex-graph 0.1.0__py3-none-any.whl

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/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/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)

memex/chat.py

@@ -0,0 +1,150 @@
+"""Chat panel widget for Memex."""
+
+import json
+from typing import Callable, Awaitable
+
+from textual.widgets import RichLog
+from rich.markdown import Markdown
+from rich.text import Text
+
+from .provider import ChatProvider, Chunk, ToolCall
+from .tools import get_all_tools, execute_tool
+
+
+SYSTEM_PROMPT = """You are Memex, an intelligent assistant with access to a knowledge graph (memex) and a decentralized social network (dagit).
+
+Available capabilities:
+- Search and query the knowledge graph (memex_search, memex_get_node, memex_traverse, etc.)
+- Create notes and save information (memex_create_node)
+- Post to the dagit social network (dagit_post)
+- Read posts from dagit (dagit_read)
+- Check your identity (dagit_whoami)
+
+When users ask questions:
+1. Use the appropriate tools to find information
+2. Synthesize the results into a helpful response
+3. If saving information, confirm what was saved
+
+Be concise but helpful. Use the tools proactively when they would help answer the user's question."""
+
+
+class ChatEngine:
+    """Manages chat state and model interactions."""
+
+    def __init__(self, first_run: bool = False):
+        self.provider = ChatProvider()
+        self.messages: list[dict] = []
+        self.tools = get_all_tools()
+        self.first_run = first_run
+
+    async def send(
+        self,
+        user_input: str,
+        on_text: Callable[[str], Awaitable[None]],
+        on_tool: Callable[[str], Awaitable[None]],
+    ) -> None:
+        """Send a message and stream the response.
+
+        Args:
+            user_input: User's message
+            on_text: Callback for text chunks
+            on_tool: Callback for tool call notifications
+        """
+        self.messages.append({"role": "user", "content": user_input})
+
+        max_turns = 10
+        for _ in range(max_turns):
+            text_buffer = ""
+            tool_calls: list[ToolCall] = []
+
+            from .onboarding import get_system_prompt
+            system_prompt = get_system_prompt(self.first_run)
+
+            for chunk in self.provider.stream(
+                system_prompt, self.messages, self.tools
+            ):
+                if chunk.type == "text":
+                    await on_text(chunk.text)
+                    text_buffer += chunk.text
+
+                elif chunk.type == "tool_call":
+                    tool_calls.append(chunk.tool_call)
+                    await on_tool(f"[{chunk.tool_call.name}]")
+
+                elif chunk.type == "error":
+                    await on_text(f"\nError: {chunk.error}")
+                    return
+
+            # If there were tool calls, execute them and continue
+            if tool_calls:
+                # Add assistant message with tool calls
+                self.messages.append(
+                    {
+                        "role": "assistant",
+                        "content": text_buffer or None,
+                        "tool_calls": [
+                            {
+                                "id": tc.id,
+                                "type": "function",
+                                "function": {
+                                    "name": tc.name,
+                                    "arguments": json.dumps(tc.arguments),
+                                },
+                            }
+                            for tc in tool_calls
+                        ],
+                    }
+                )
+
+                # Execute tools and add results
+                for tc in tool_calls:
+                    result = execute_tool(tc.name, tc.arguments)
+                    self.messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tc.id,
+                            "content": result,
+                        }
+                    )
+                continue
+
+            # No tool calls - conversation turn complete
+            if text_buffer:
+                self.messages.append({"role": "assistant", "content": text_buffer})
+            return
+
+    def clear(self) -> None:
+        """Clear conversation history."""
+        self.messages.clear()
+
+
+class ChatPanel(RichLog):
+    """Chat display panel with rich formatting."""
+
+    def __init__(self, **kwargs):
+        super().__init__(markup=True, wrap=True, **kwargs)
+
+    def add_user_message(self, text: str) -> None:
+        """Add a user message to the display."""
+        self.write(Text.from_markup(f"[bold cyan]You:[/bold cyan] {text}"))
+
+    def add_assistant_text(self, text: str) -> None:
+        """Add assistant text (streaming)."""
+        # For streaming, we append to the current line
+        self.write(text, scroll_end=True)
+
+    def start_assistant_response(self) -> None:
+        """Start a new assistant response line."""
+        self.write(Text.from_markup("[bold green]Memex:[/bold green] "), scroll_end=True)
+
+    def add_tool_indicator(self, tool_name: str) -> None:
+        """Show a tool being called."""
+        self.write(Text.from_markup(f"[dim]{tool_name}[/dim]"))
+
+    def add_error(self, error: str) -> None:
+        """Display an error message."""
+        self.write(Text.from_markup(f"[bold red]Error:[/bold red] {error}"))
+
+    def add_system_message(self, text: str) -> None:
+        """Display a system message."""
+        self.write(Text.from_markup(f"[dim italic]{text}[/dim italic]"))

memex/onboarding.py

@@ -0,0 +1,23 @@
+"""First-run onboarding prompt for new users."""
+
+from .chat import SYSTEM_PROMPT
+
+ONBOARDING_ADDENDUM = """
+
+IMPORTANT: This is the user's first time using memex. Follow these steps:
+
+1. Start by calling `dagit_whoami` to look up the user's decentralized identity (DID).
+2. Welcome the user and show them their DID.
+3. Explain memex in 2 sentences: it's a personal knowledge graph where you can save thoughts, notes, and connections — paired with a decentralized social network (dagit) where you can publish and share using your cryptographic identity.
+4. Ask the user for their first thought, idea, or note they'd like to save.
+5. When they provide one, save it using `memex_create_node` with type "Note".
+6. After saving, suggest they post an introduction to dagit using `dagit_post` — something like "Hello from memex! My first note: ..."
+
+Be warm, concise, and encouraging. This is their first experience — make it count."""
+
+
+def get_system_prompt(first_run: bool) -> str:
+    """Return system prompt, with onboarding addendum if first run."""
+    if first_run:
+        return SYSTEM_PROMPT + ONBOARDING_ADDENDUM
+    return SYSTEM_PROMPT