duckbrain 0.1.1__py3-none-any.whl

duckbrain/__init__.py

@@ -0,0 +1,38 @@
+"""DuckBrain — DuckDB-backed MCP memory server for Obsidian vaults."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class PageMetadata:
+    """Parsed metadata and body from a single wiki markdown page."""
+
+    filepath: str
+    title: str
+    kind: str  # entity, concept, source, synthesis
+    tags: list[str] = field(default_factory=list)
+    body: str = ""
+    created: str = ""
+    updated: str = ""
+
+
+@dataclass
+class SearchResult:
+    """A single FTS search hit."""
+
+    title: str
+    kind: str
+    filepath: str
+    snippet: str
+    created: str = ""
+    updated: str = ""
+    matched_tags: list[str] = field(default_factory=list)
+
+
+@dataclass
+class WriteResult:
+    """Result of a vault_write operation."""
+
+    success: bool
+    filepath: str
+    warnings: list[str] = field(default_factory=list)

duckbrain/indexer.py

@@ -0,0 +1,180 @@
+"""DuckDB FTS index build, search, and stats for DuckBrain."""
+
+from typing import Any
+
+import duckdb
+
+from duckbrain import PageMetadata
+
+
+def build_fts_index(pages: list[PageMetadata]) -> duckdb.DuckDBPyConnection:
+    """Build a DuckDB in-memory FTS index from a list of PageMetadata.
+
+    Creates an in-memory DuckDB connection, creates a ``pages`` table,
+    inserts all pages, and builds an FTS index on title, tags, and body.
+    Returns the connection (caller must close it).
+    """
+    conn = duckdb.connect(":memory:")
+
+    # Load FTS extension
+    conn.execute("INSTALL fts")
+    conn.execute("LOAD fts")
+
+    # Create the pages table
+    conn.execute(
+        "CREATE TABLE pages ("
+        "  filepath VARCHAR,"
+        "  title    VARCHAR,"
+        "  kind     VARCHAR,"
+        "  tags     VARCHAR,"
+        "  body     VARCHAR,"
+        "  created  VARCHAR,"
+        "  updated  VARCHAR"
+        ")"
+    )
+
+    # Insert all pages (tags joined as comma-separated string for FTS)
+    for p in pages:
+        conn.execute(
+            "INSERT INTO pages VALUES (?, ?, ?, ?, ?, ?, ?)",
+            [
+                p.filepath,
+                p.title,
+                p.kind,
+                ",".join(p.tags),
+                p.body,
+                p.created,
+                p.updated,
+            ],
+        )
+
+    # Build FTS index on title, tags, body — using filepath as the document id
+    conn.execute("PRAGMA create_fts_index('pages', 'filepath', 'title', 'tags', 'body')")
+
+    return conn
+
+
+def search(
+    conn: duckdb.DuckDBPyConnection,
+    query: str,
+    kind: str | None = None,
+    tags: list[str] | None = None,
+) -> list[dict[str, Any]]:
+    """Search the FTS index and return matching results.
+
+    Parameters
+    ----------
+    conn:
+        DuckDB connection with a built FTS index.
+    query:
+        Search text (used for BM25 matching).
+    kind:
+        Optional kind filter (e.g. ``"concept"``).
+    tags:
+        Optional list of tag substrings to filter by.
+
+    Returns
+    -------
+    list[dict]
+        Each dict has keys ``title``, ``kind``, ``filepath``, ``snippet``,
+        ``created``, ``updated``.
+    """
+    # Build the query dynamically.
+    # The FTS match uses the fts_main_pages.match_bm25 function.
+    conditions: list[str] = []
+    params: dict[str, Any] = {"query": query}
+
+    if kind is not None:
+        conditions.append("p.kind = $kind")
+        params["kind"] = kind
+
+    if tags:
+        tag_clauses: list[str] = []
+        for i, tag in enumerate(tags):
+            param = f"tag_{i}"
+            tag_clauses.append(f"p.tags LIKE ${param}")
+            params[param] = f"%{tag}%"
+        conditions.append("(" + " OR ".join(tag_clauses) + ")")
+
+    where_clause = ""
+    if conditions:
+        where_clause = " AND " + " AND ".join(conditions)
+
+    sql = f"""
+        SELECT p.title, p.kind, p.filepath, p.body, p.created, p.updated
+        FROM (
+            SELECT *, fts_main_pages.match_bm25(p.filepath, $query) AS score
+            FROM pages p
+        ) p
+        WHERE score IS NOT NULL{where_clause}
+        ORDER BY score DESC
+    """
+
+    rows = conn.execute(sql, params).fetchall()
+
+    results: list[dict[str, Any]] = []
+    for row in rows:
+        title, kind_val, filepath, body, created, updated = row
+        # Build a simple snippet: first 100 chars of body
+        snippet = body[:100] + "..." if len(body) > 100 else body
+        results.append(
+            {
+                "title": title,
+                "kind": kind_val,
+                "filepath": filepath,
+                "snippet": snippet,
+                "created": created,
+                "updated": updated,
+            }
+        )
+
+    return results
+
+
+def get_stats(
+    conn: duckdb.DuckDBPyConnection,
+) -> dict[str, Any]:
+    """Get statistics from the indexed pages.
+
+    Returns
+    -------
+    dict
+        Keys: ``entities``, ``concepts``, ``sources``, ``synthesis``,
+        ``daily``, ``available_tags``, ``last_modified``.
+    """
+    # Count by kind
+    kind_counts: dict[str, int] = {
+        "entity": 0,
+        "concept": 0,
+        "source": 0,
+        "synthesis": 0,
+        "daily": 0,
+    }
+    rows = conn.execute("SELECT kind, COUNT(*) FROM pages GROUP BY kind").fetchall()
+    for kind_val, count in rows:
+        kind_counts[kind_val] = count
+
+    # Collect unique tags
+    tag_rows = conn.execute("SELECT DISTINCT tags FROM pages").fetchall()
+    all_tags: set[str] = set()
+    for (tag_str,) in tag_rows:
+        if tag_str:
+            for t in tag_str.split(","):
+                t_stripped = t.strip()
+                if t_stripped:
+                    all_tags.add(t_stripped)
+
+    # Max updated date
+    row = conn.execute("SELECT MAX(updated) FROM pages").fetchone()
+    max_updated = row[0] if row else None
+    last_modified: str | None = str(max_updated) if max_updated else None
+
+    return {
+        "entities": kind_counts["entity"],
+        "concepts": kind_counts["concept"],
+        "sources": kind_counts["source"],
+        "synthesis": kind_counts["synthesis"],
+        "daily": kind_counts["daily"],
+        "available_tags": sorted(all_tags),
+        "last_modified": last_modified,
+    }

duckbrain/scanner.py

@@ -0,0 +1,140 @@
+"""Vault file discovery and YAML frontmatter parsing."""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from duckbrain import PageMetadata
+
+
+def parse_frontmatter(content: str) -> tuple[dict[str, Any], str]:
+    """Parse YAML frontmatter from a markdown string.
+
+    Returns:
+        A tuple of (frontmatter_dict, body_text). If no frontmatter is found or
+        YAML parsing fails, returns ({}, content) unchanged.
+    """
+    if not content.startswith("---"):
+        return {}, content
+
+    # Find the closing `---`
+    end_idx = content.find("---", 3)
+    if end_idx == -1:
+        return {}, content
+
+    yaml_block = content[3:end_idx].strip()
+    body = content[end_idx + 3 :].strip()
+
+    if not yaml_block:
+        return {}, body
+
+    try:
+        meta = yaml.safe_load(yaml_block)
+        if not isinstance(meta, dict):
+            return {}, content
+        return meta, body
+    except yaml.YAMLError:
+        return {}, content
+
+
+def scan_vault(vault_path: str) -> list[PageMetadata]:
+    """Scan an Obsidian vault for wiki pages with valid item-type frontmatter.
+
+    Globs ``wiki/{entities,concepts,sources,synthesis}/*.md`` under *vault_path*
+    and returns a :class:`PageMetadata` for each file that has an ``item-type``
+    key matching the parent directory name.
+
+    Args:
+        vault_path: Root path of the Obsidian vault.
+
+    Returns:
+        A list of :class:`PageMetadata` objects (one per discovered page).
+    """
+    vault = Path(vault_path)
+    pages: list[PageMetadata] = []
+
+    kind_to_dir = {
+        "entity": "entities",
+        "concept": "concepts",
+        "source": "sources",
+        "synthesis": "synthesis",
+    }
+
+    # Build a reverse map: parent dir name → kind
+    dir_to_kind = {v: k for k, v in kind_to_dir.items()}
+
+    for subdir in kind_to_dir.values():
+        glob_pattern = f"wiki/{subdir}/*.md"
+        for filepath in sorted(vault.glob(glob_pattern)):
+            try:
+                content = filepath.read_text(encoding="utf-8")
+            except (OSError, UnicodeDecodeError):
+                continue  # skip unreadable files
+
+            meta, body = parse_frontmatter(content)
+
+            item_type = meta.get("item-type")
+            if not item_type:
+                continue
+
+            # Infer kind from parent directory name
+            parent_dir = filepath.parent.name
+            kind = dir_to_kind.get(parent_dir, item_type)
+
+            title = meta.get("title", filepath.stem)
+            tags = meta.get("tags", [])
+            created = meta.get("created", "")
+            updated = meta.get("updated", "")
+
+            pages.append(
+                PageMetadata(
+                    filepath=str(filepath.relative_to(vault)),
+                    title=title,
+                    kind=kind,
+                    tags=tags if isinstance(tags, list) else [],
+                    body=body,
+                    created=created,
+                    updated=updated,
+                )
+            )
+
+    pages.extend(scan_daily(vault_path))
+    return pages
+
+
+def scan_daily(vault_path: str) -> list[PageMetadata]:
+    """Scan daily notes (``daily/*.md``).
+
+    Daily files have no YAML frontmatter — all metadata is derived from the
+    filename (title = filename stem, created/updated = filename date).
+
+    Args:
+        vault_path: Root path of the Obsidian vault.
+
+    Returns:
+        A list of :class:`PageMetadata` objects (one per daily file).
+    """
+    daily_dir = Path(vault_path) / "daily"
+    if not daily_dir.is_dir():
+        return []
+
+    pages: list[PageMetadata] = []
+    for md_file in sorted(daily_dir.glob("*.md")):
+        date_str = md_file.stem
+        try:
+            body = md_file.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError):
+            continue
+        pages.append(
+            PageMetadata(
+                filepath=str(md_file.relative_to(Path(vault_path))),
+                title=date_str,
+                kind="daily",
+                tags=[],
+                body=body,
+                created=date_str,
+                updated=date_str,
+            )
+        )
+    return pages

duckbrain/server.py

@@ -0,0 +1,95 @@
+"""DuckBrain MCP server — stdio transport."""
+
+import os
+import sys
+
+from dotenv import load_dotenv
+from mcp.server.fastmcp import FastMCP
+from mcp.types import Icon
+
+from duckbrain.tools.vault_info import handle_vault_info
+from duckbrain.tools.vault_read import handle_vault_read
+from duckbrain.tools.vault_search import handle_vault_search
+from duckbrain.tools.vault_write import handle_vault_write
+
+# Load .env from project root (or current working directory).
+load_dotenv()
+
+# Handle the case where MCP config sets VAULT_PATH to empty string
+# (e.g. OpenCode's {env:VAULT_PATH} when the var is not in shell),
+# which blocks load_dotenv from loading the .env value.
+if os.environ.get("VAULT_PATH", "").strip() == "":
+    os.environ.pop("VAULT_PATH", None)
+    load_dotenv()
+
+
+def get_vault_path() -> str:
+    """Return vault path from VAULT_PATH env var."""
+    vault_path = os.environ.get("VAULT_PATH")
+    if not vault_path:
+        print(
+            "VAULT_PATH is empty or not set.\n"
+            "\n"
+            "Fix: copy .env.example → .env and set VAULT_PATH to your vault.\n"
+            "    cp .env.example .env\n"
+            "    # edit .env with your vault path\n"
+            "\n"
+            "If using {env:VAULT_PATH} in MCP config, either:\n"
+            "  a) Set VAULT_PATH in your shell (~/.bashrc, ~/.zshrc etc.)\n"
+            "  b) Remove the 'environment' block from the MCP config so .env is used",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    return vault_path
+
+
+def main() -> None:
+    """Entry point: start MCP server on stdio."""
+    vault_path = get_vault_path()
+    server = FastMCP(
+        "duckbrain-vault",
+        icons=[
+            Icon(
+                src="https://raw.githubusercontent.com/timhiebenthal/duckbrain/main/logo/favicon.png",
+                mimeType="image/png",
+                sizes=["64x64"],
+            )
+        ],
+    )
+
+    @server.tool()
+    def vault_info() -> dict:
+        """Get vault structure stats: page counts by kind, available tags, last modified date."""
+        return handle_vault_info(vault_path)
+
+    @server.tool()
+    def vault_read(title: str | None = None, filepath: str | None = None) -> dict:
+        """Read a wiki or daily page. Pass either title or filepath (from vault_search results)."""
+        return handle_vault_read(vault_path, title=title, filepath=filepath)
+
+    @server.tool()
+    def vault_search(
+        query: str,
+        kind: str | None = None,
+        tags: list[str] | None = None,
+    ) -> list[dict]:
+        """Full-text search over vault wiki pages. Returns ranked results with snippets."""
+        return handle_vault_search(vault_path, query, kind, tags)
+
+    @server.tool()
+    def vault_write(kind: str, title: str, content: str, tags: list[str]) -> dict:
+        """Create a new wiki page or append to today's daily note.
+
+        Args:
+            kind: entity | concept | source | synthesis | daily
+            title: Page title (or daily section heading)
+            content: Markdown body (without frontmatter)
+            tags: List of tag strings
+        """
+        return handle_vault_write(vault_path, kind, title, content, tags)
+
+    server.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

duckbrain/tools/vault_info.py

@@ -0,0 +1,29 @@
+"""MCP tool: vault_info — vault structure summary."""
+
+from typing import Any
+
+from duckbrain.indexer import build_fts_index, get_stats
+from duckbrain.scanner import scan_vault
+
+
+def handle_vault_info(vault_path: str) -> dict[str, Any]:
+    """Return vault structure statistics.
+
+    Scans the vault, builds an in-memory FTS index, and returns
+    counts per kind (entities, concepts, sources, synthesis),
+    the sorted list of all unique tags, and the last-modified date.
+
+    Args:
+        vault_path: Root path of the Obsidian vault.
+
+    Returns:
+        A dict with keys: ``entities``, ``concepts``, ``sources``,
+        ``synthesis``, ``daily``, ``available_tags``, ``last_modified``.
+    """
+    pages = scan_vault(vault_path)
+    conn = build_fts_index(pages)
+    try:
+        stats = get_stats(conn)
+    finally:
+        conn.close()
+    return stats

duckbrain/tools/vault_read.py

@@ -0,0 +1,72 @@
+"""MCP tool: vault_read — read a page by title or filepath."""
+
+from pathlib import Path
+from typing import Any
+
+from duckbrain.scanner import scan_vault
+
+
+def handle_vault_read(
+    vault_path: str,
+    title: str | None = None,
+    filepath: str | None = None,
+) -> dict[str, Any]:
+    """Read a wiki or daily page by title or filepath.
+
+    When *filepath* is given (e.g. from :func:`vault_search` results),
+    the file is read directly. When *title* is given, the vault is
+    scanned to locate the matching page.
+
+    Args:
+        vault_path: Root path of the Obsidian vault.
+        title: Page title to look up (case-insensitive).
+        filepath: Relative path within the vault (e.g. ``wiki/concepts/foo.md``).
+
+    Returns:
+        A dict with ``title``, ``kind``, ``filepath``, ``content``,
+        ``tags``, ``created``, ``updated`` — or an ``error`` key if not found.
+    """
+    # filepath takes priority — direct read, no scan needed
+    if filepath:
+        full_path = Path(vault_path) / filepath
+        if not full_path.is_file():
+            return {"error": f"File not found: {filepath}"}
+
+        content = full_path.read_text(encoding="utf-8")
+        # Try to extract title from frontmatter for metadata, but don't fail
+        # if the file has no frontmatter (e.g. daily notes).
+        title_from_file = filepath.rsplit("/", 1)[-1].removesuffix(".md")
+        kind = "daily" if filepath.startswith("daily/") else "wiki"
+
+        return {
+            "title": title_from_file,
+            "kind": kind,
+            "filepath": filepath,
+            "content": content,
+            "tags": [],
+            "created": "",
+            "updated": "",
+        }
+
+    # title lookup — scan and find match
+    if title:
+        pages = scan_vault(vault_path)
+        title_lower = title.strip().lower()
+
+        for page in pages:
+            if page.title.lower() == title_lower:
+                full_path = Path(vault_path) / page.filepath
+                if full_path.is_file():
+                    return {
+                        "title": page.title,
+                        "kind": page.kind,
+                        "filepath": page.filepath,
+                        "content": full_path.read_text(encoding="utf-8"),
+                        "tags": page.tags,
+                        "created": page.created,
+                        "updated": page.updated,
+                    }
+
+        return {"error": f"Page not found: {title}"}
+
+    return {"error": "Provide either title or filepath"}

duckbrain/tools/vault_search.py

@@ -0,0 +1,38 @@
+"""MCP tool: vault_search — search the vault using FTS."""
+
+from typing import Any
+
+from duckbrain.indexer import build_fts_index, search
+from duckbrain.scanner import scan_vault
+
+
+def handle_vault_search(
+    vault_path: str,
+    query: str,
+    kind: str | None = None,
+    tags: list[str] | None = None,
+) -> list[dict[str, Any]]:
+    """Search the vault for pages matching *query* using full-text search.
+
+    Parameters
+    ----------
+    vault_path:
+        Root path of the Obsidian vault.
+    query:
+        Search text (used for BM25 matching on title, tags, and body).
+    kind:
+        Optional kind filter (e.g. ``"concept"``).
+    tags:
+        Optional list of tag substrings to filter by.
+
+    Returns
+    -------
+    list[dict]
+        Each dict has keys ``title``, ``kind``, ``filepath``, ``snippet``.
+    """
+    pages = scan_vault(vault_path)
+    conn = build_fts_index(pages)
+    try:
+        return search(conn, query, kind, tags)
+    finally:
+        conn.close()

duckbrain/tools/vault_write.py

@@ -0,0 +1,31 @@
+"""MCP tool: vault_write — create new wiki pages with index/log updates."""
+
+from typing import Any
+
+from duckbrain.writer import write_page
+
+
+def handle_vault_write(
+    vault_path: str,
+    kind: str,
+    title: str,
+    content: str,
+    tags: list[str],
+) -> dict[str, Any]:
+    """Create a new wiki page in the vault.
+
+    Delegates to :func:`duckbrain.writer.write_page` which handles
+    frontmatter generation, file creation, and index/log updates.
+
+    Args:
+        vault_path: Root path of the Obsidian vault.
+        kind: Page kind — ``entity``, ``concept``, ``source``, or ``synthesis``.
+        title: Page title.
+        content: Markdown body content (without frontmatter).
+        tags: List of tag strings.
+
+    Returns:
+        A dict with keys ``success`` (bool), ``filepath`` (str, relative),
+        and ``warnings`` (list of str).
+    """
+    return write_page(vault_path, kind, title, content, tags)

duckbrain/writer.py

@@ -0,0 +1,253 @@
+"""Page creation with frontmatter generation, index/log auto-update."""
+
+import re
+from datetime import date
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+# Map page kind to index section header name
+KIND_TO_SECTION: dict[str, str] = {
+    "entity": "Entities",
+    "concept": "Concepts",
+    "source": "Sources",
+    "synthesis": "Synthesis",
+}
+
+# Map page kind to subdirectory under wiki/
+KIND_TO_SUBDIR: dict[str, str] = {
+    "entity": "entities",
+    "concept": "concepts",
+    "source": "sources",
+    "synthesis": "synthesis",
+}
+
+
+def generate_frontmatter(kind: str, title: str, tags: list[str]) -> str:
+    """Generate YAML frontmatter block for a new wiki page.
+
+    Returns a string wrapped in ``---`` delimiters with keys:
+    ``title``, ``item-type`` (mapped from *kind*), ``tags``,
+    ``created``, and ``updated`` (both set to today's date).
+
+    Args:
+        kind: Page kind — ``entity``, ``concept``, ``source``, or ``synthesis``.
+        title: Page title.
+        tags: List of tag strings.
+
+    Returns:
+        A string containing the complete YAML frontmatter block
+        including the ``---`` delimiters.
+    """
+    today = date.today().isoformat()
+    data: dict[str, Any] = {
+        "title": title,
+        "item-type": kind,
+        "tags": tags,
+        "created": today,
+        "updated": today,
+    }
+    yaml_str = yaml.dump(data, default_flow_style=False, allow_unicode=True)
+    return f"---\n{yaml_str}---"
+
+
+def slugify(title: str) -> str:
+    """Convert a title to a URL-friendly slug.
+
+    - Lowercases the title
+    - Replaces any non-alphanumeric character (except spaces) with ``-``
+    - Collapses multiple dashes/spaces to a single dash
+    - Strips leading/trailing dashes
+
+    Examples:
+        >>> slugify("Claude Mem")
+        'claude-mem'
+        >>> slugify("BI's Second Unbundling")
+        'bis-second-unbundling'
+    """
+    # Lowercase
+    slug = title.lower()
+    # Remove apostrophes entirely (they should not become dashes)
+    slug = slug.replace("'", "")
+    # Replace any remaining non-alphanumeric (except spaces) with dash
+    slug = re.sub(r"[^a-z0-9\s]", "-", slug)
+    # Collapse multiple dashes/spaces to single dash
+    slug = re.sub(r"[\s-]+", "-", slug)
+    # Strip leading/trailing dashes
+    slug = slug.strip("-")
+    return slug
+
+
+def _write_daily(
+    vault_path: str,
+    title: str,
+    content: str,
+    tags: list[str],
+) -> dict[str, Any]:
+    """Append a section to today's daily note.
+
+    Daily notes live under ``daily/YYYY-MM-DD.md`` in the vault root
+    (not under ``wiki/``).  They have no YAML frontmatter and are
+    **appended** to — the file grows throughout the day.
+
+    Args:
+        vault_path: Root path of the Obsidian vault.
+        title: Section heading for this daily entry.
+        content: Markdown body content.
+        tags: List of tag strings.
+
+    Returns:
+        A dict with keys ``success`` (bool), ``filepath`` (str, relative),
+        and ``warnings`` (list of str).
+    """
+    warnings: list[str] = []
+    today = date.today().isoformat()
+    relative_path = f"daily/{today}.md"
+    filepath = Path(vault_path) / relative_path
+
+    # Build the entry body
+    entry = f"\n## {title}\n\n{content}\n"
+    if tags:
+        entry += f"\n**Tags:** {', '.join(tags)}\n"
+
+    # Create daily directory if needed
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+
+    # If file doesn't exist yet, prepend a top-level date heading
+    if not filepath.exists():
+        entry = f"# {today}\n{entry}"
+
+    # Append to file (always — daily notes accumulate)
+    with filepath.open("a") as f:
+        f.write(entry)
+
+    # Update log.md (but NOT index.md — daily pages aren't in the wiki index)
+    log_path = Path(vault_path) / "wiki" / "log.md"
+    try:
+        log_entry = f"## [{today}] daily | {title}\n- Added to daily note: {title}\n"
+        with log_path.open("a") as f:
+            f.write(log_entry)
+    except OSError as e:
+        warnings.append(f"Failed to update log.md: {e}")
+
+    return {
+        "success": True,
+        "filepath": relative_path,
+        "warnings": warnings,
+    }
+
+
+def write_page(
+    vault_path: str,
+    kind: str,
+    title: str,
+    content: str,
+    tags: list[str],
+) -> dict[str, Any]:
+    """Create a new wiki page in the vault and update index/log.
+
+    Steps:
+    1. Derive slug from title → filename
+    2. Map *kind* to subdirectory under ``wiki/``
+    3. Generate full markdown with frontmatter
+    4. Write file to disk (creating subdirectories as needed)
+    5. Append log entry to ``wiki/log.md``
+    6. Insert index entry in ``wiki/index.md`` under the correct section
+
+    Args:
+        vault_path: Root path of the Obsidian vault.
+        kind: Page kind — ``entity``, ``concept``, ``source``, or ``synthesis``.
+        title: Page title.
+        content: Markdown body content (without frontmatter).
+        tags: List of tag strings.
+
+    Returns:
+        A dict with keys ``success`` (bool), ``filepath`` (str, relative),
+        and ``warnings`` (list of str).
+    """
+    if kind == "daily":
+        return _write_daily(vault_path, title, content, tags)
+
+    warnings: list[str] = []
+    today = date.today().isoformat()
+
+    # 1. Derive slug and subdirectory
+    slug = slugify(title)
+    subdir = KIND_TO_SUBDIR.get(kind, kind)
+    relative_path = f"wiki/{subdir}/{slug}.md"
+    filepath = Path(vault_path) / relative_path
+
+    # 2. Generate full markdown
+    frontmatter = generate_frontmatter(kind, title, tags)
+    full_markdown = f"{frontmatter}\n\n{content}"
+
+    # 3. Write file (create subdirectories if needed)
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text(full_markdown)
+
+    # 4. Append to wiki/log.md
+    log_path = Path(vault_path) / "wiki" / "log.md"
+    try:
+        log_entry = f"## [{today}] ingest | {title}\n- Created {kind}: {title}\n"
+        with log_path.open("a") as f:
+            f.write(log_entry)
+    except OSError as e:
+        warnings.append(f"Failed to update log.md: {e}")
+
+    # 5. Update wiki/index.md
+    index_path = Path(vault_path) / "wiki" / "index.md"
+    try:
+        section_name = KIND_TO_SECTION.get(kind, kind.capitalize())
+        section_header = f"## {section_name}"
+        index_entry = f"- [[{title}]] - {title}"
+
+        content_bytes = index_path.read_text()
+        lines = content_bytes.splitlines(keepends=True)
+
+        new_lines: list[str] = []
+        inserted = False
+        in_section = False
+
+        for i, line in enumerate(lines):
+            if line.rstrip() == section_header:
+                in_section = True
+                new_lines.append(line)
+                continue
+
+            if in_section:
+                # Check if this line starts a new section (next ## header)
+                if line.startswith("## ") and line.rstrip() != section_header:
+                    # Insert before the next section header
+                    new_lines.append(index_entry + "\n")
+                    inserted = True
+                    in_section = False
+                elif i == len(lines) - 1:
+                    # Last line — append entry after it
+                    new_lines.append(line)
+                    if not line.endswith("\n"):
+                        new_lines.append("\n")
+                    new_lines.append(index_entry + "\n")
+                    inserted = True
+                    in_section = False
+                    continue
+
+            new_lines.append(line)
+
+        # If we never found a boundary, append at the end
+        if in_section and not inserted:
+            new_lines.append(index_entry + "\n")
+
+        if inserted or in_section:
+            index_path.write_text("".join(new_lines))
+        else:
+            warnings.append(f"Section '{section_header}' not found in index.md")
+
+    except OSError as e:
+        warnings.append(f"Failed to update index.md: {e}")
+
+    return {
+        "success": True,
+        "filepath": relative_path,
+        "warnings": warnings,
+    }

duckbrain-0.1.1.dist-info/METADATA

@@ -0,0 +1,438 @@
+Metadata-Version: 2.4
+Name: duckbrain
+Version: 0.1.1
+Summary: DuckDB-backed MCP memory server for Obsidian vaults — structured search, read, and write access for AI coding agents.
+Keywords: mcp,obsidian,memory,knowledge-base,duckdb,ai-agent
+Author: Tim Hiebenthal
+Author-email: Tim Hiebenthal <timhiebenthal@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: duckdb>=1.5.3
+Requires-Dist: mcp[cli]>=1.27.1
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: pyyaml>=6.0.3
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/timhiebenthal/duckbrain
+Project-URL: Repository, https://github.com/timhiebenthal/duckbrain
+Project-URL: Issues, https://github.com/timhiebenthal/duckbrain/issues
+Description-Content-Type: text/markdown
+
+# DuckBrain
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/timhiebenthal/duckbrain/main/logo/logo_writing_white_bg.png" alt="DuckBrain" width="500" />
+</p>
+
+DuckDB-backed MCP memory server for Obsidian vaults. Gives AI coding agents structured read and write access to your personal wiki — with full-text search, frontmatter-aware indexing, and automatic index/log updates. Built on the principle that your vault filesystem should be the single source of truth, not a database hidden behind an API.
+
+## What it solves
+
+Existing agent memory tools (MemSearch, Open Brain, Mem0, Supermemory) treat memory as unstructured text blobs. If you maintain a [Karpathy-style LLM wiki](https://x.com/karpathy/status/1889054630119760374) in Obsidian with typed pages (entities, concepts, sources, synthesis), YAML frontmatter, tags, and wikilinks — none of those tools understand your vault's structure.
+
+DuckBrain fills that gap. It reads your vault as-is and writes new pages following your vault's schema, so your wiki stays a single source of truth on the filesystem.
+
+## How it works (Architecture)
+
+```
+┌──────────────────┐     MCP stdio     ┌─────────────────────────────────┐
+│    AI Agent      │ ◄──────────────►  │      DuckBrain MCP Server       │
+│                  │                   │                                 │
+│  Claude Code     │                   │  vault_info  ──┐                │
+│  OpenCode        │                   │  vault_search ─┤  DuckDB FTS    │
+│  Cursor          │                   │  vault_read  ──┤  Filesystem    │
+│  Hermes          │                   │  vault_write ──┘  Filesystem    │
+└──────────────────┘                   └────────┬────────┬───────────────┘
+                                                │        │
+                    query ┌─────────────────────┘        └── read/write ──┐
+             (full index) ▼                                               ▼  (single file)
+         ┌──────────────────────┐                              ┌───────────────────────────┐
+         │  DuckDB (in-memory)  │                              │    Your Obsidian Vault    │
+         │                      │                              │                           │
+         │  pages (in-memory    │    rebuilt from scratch      │  wiki/entities/           │
+         │  rebuilt every search)│    on every query           │  wiki/concepts/           │
+         │  ┌───────────────┐   │                              │  wiki/sources/            │
+         │  │ filepath      │   │                              │  wiki/synthesis/          │
+         │  │ title         │   │                              │  daily/                   │
+         │  │ kind          │   │                              │  wiki/index.md            │
+         │  │ tags          │   │                              │  wiki/log.md              │
+         │  │ body          │   │                              │                           │
+         │  │ created       │   │                              │  plain markdown on disk   │
+         │  │ updated       │   │                              │                           │
+         │  └───────────────┘   │                              │                           │
+         │                      │                              │                           │
+         │  BM25 search query:  │                              │                           │
+         │  SELECT ...          │                              │                           │
+         │  FROM pages p        │                              │                           │
+         │  WHERE fts_match_bm25│                              │                           │
+         │    (p.filepath,      │                              │                           │
+         │     'segfault')      │                              │                           │
+         │  AND kind='concept'  │                              │                           │
+         │  ORDER BY score DESC │                              │                           │
+         └──────────────────────┘                              └───────────────────────────┘
+```
+
+- **Reads** your vault files directly — no index to sync, no watchers, no duplicate storage
+- **Searches** via DuckDB full-text search (BM25 ranking), rebuilt fresh from disk on every query
+- **Writes** new pages with correct YAML frontmatter, auto-updating your index and log
+
+## Requirements
+
+- Python 3.10+
+- [uv](https://docs.astral.sh/uv/) (package manager)
+- An Obsidian vault structured with a `wiki/` directory containing:
+  - `wiki/entities/` — people, orgs, products, tools
+  - `wiki/concepts/` — ideas, frameworks, theories
+  - `wiki/sources/` — one summary per ingested source
+  - `wiki/synthesis/` — cross-cutting analysis
+  - `wiki/index.md` — page catalog with `## Entities`, `## Concepts`, `## Sources`, `## Synthesis` sections
+  - `wiki/log.md` — append-only chronological record
+- Pages should use YAML frontmatter: `title`, `item-type`, `tags`, `created`, `updated`
+
+This follows the schema defined for [LLM wikis](https://x.com/karpathy/status/1889054630119760374). If your vault uses a different structure, DuckBrain works with it — but index/log updates expect the section headers above.
+
+## Quick Start
+
+```bash
+pip install duckbrain
+```
+
+That's it. Now connect your AI agent (see below) — you don't run DuckBrain yourself, the agent spawns it as needed.
+
+*(Optional: verify the install by running `duckbrain` — it'll fail with "VAULT_PATH not set", which confirms it's working.)*
+
+### Installing from source (for contributors)
+
+```bash
+git clone https://github.com/timhiebenthal/duckbrain.git
+cd duckbrain
+uv sync         # installs project + dev dependencies in a virtual environment
+```
+
+This requires [uv](https://docs.astral.sh/uv/) (the Python package manager used for development). End users should use `pip install duckbrain` above.
+
+*(Optional: to verify the install, run `VAULT_PATH="/path/to/your/vault" uv run duckbrain`. It will appear to hang — that's correct, it's waiting on stdio. Press Ctrl+C to stop.)*
+
+## Connecting to Agents
+
+MCP stdio transport means the agent spawns DuckBrain as a child process when it starts. You don't need a separate terminal or a running server. Just add this to your MCP config:
+
+```json
+{
+  "duckbrain": {
+    "command": "uv",
+    "args": ["run", "duckbrain"],
+    "env": {
+      "VAULT_PATH": "/path/to/your/obsidian/vault"
+    }
+  }
+}
+```
+
+Where to put it:
+
+| Agent | Config file | Top-level key |
+|-------|-------------|---------------|
+| Claude Code | `~/.claude/claude_desktop_config.json` or `.mcp.json` | `mcpServers` |
+| OpenCode | `opencode.json` | `mcp` |
+| Cursor | `.cursor/mcp.json` | `mcpServers` |
+| Hermes Agent | `mcp.json` | `mcpServers` |
+
+Example for Claude Code:
+```json
+{
+  "mcpServers": {
+    "duckbrain": {
+      "command": "uv",
+      "args": ["run", "duckbrain"],
+      "env": {
+        "VAULT_PATH": "/path/to/your/obsidian/vault"
+      }
+    }
+  }
+}
+```
+
+> **Tip:** Instead of hardcoding the path in every config, set `VAULT_PATH` once in your shell profile (`~/.bashrc`, `~/.zshrc`, or `~/.config/fish/config.fish`) and reference it in the config with your agent's env-var syntax:
+>
+> - OpenCode: `"VAULT_PATH": "{env:VAULT_PATH}"`
+> - Claude Code: `"VAULT_PATH": "${env:VAULT_PATH}"`
+
+Make sure `uv` is on your `PATH`.
+
+### Auto-Writing Session Learnings
+
+There are two ways to make your agent write learnings to the vault: instructions (works everywhere) or hooks (automatic, agent-native).
+
+#### Approach 1: Instructions (all agents)
+
+Add this to the appropriate instructions file. The agent reads it on startup and follows it during the session. **Tested with OpenCode.**
+
+**Claude Code** — add to `CLAUDE.md`:
+
+```markdown
+## Session Learnings
+
+After debugging, diving into rabbit holes, or completing significant work,
+save what you learned so you don't repeat mistakes:
+
+- Use vault_write(kind="daily", title="...", content="...", tags=["..."])
+  to append to today's daily note.
+- For reusable knowledge, use vault_write(kind="concept", title="...",
+  content="...", tags=["..."]) to create a wiki page.
+```
+
+**OpenCode** — add to your config's `instructions` field (`opencode.json`):
+
+```json
+"instructions": ["~/.config/opencode/LEARNINGS.md"]
+```
+
+Then create `~/.config/opencode/LEARNINGS.md` (or wherever you prefer — any path the config can reach):
+
+```markdown
+## Session Learnings
+
+When you encounter problems, debug issues, or discover non-obvious solutions,
+save the learning to the vault so it's available in future sessions:
+
+- Append to today's daily note:
+  vault_write(kind="daily", title="short summary", content="what you learned", tags=["debugging", "learned"])
+
+- For reusable concepts/patterns worth revisiting:
+  vault_write(kind="concept", title="Concept Name", content="explanation", tags=["relevant", "tags"])
+
+Do this proactively — don't wait to be asked. A learning saved is a bug not repeated.
+```
+
+**Cursor** — add to `.cursorrules`:
+
+```markdown
+## Session Learnings
+
+After debugging or completing work, save learnings via DuckBrain:
+- vault_write(kind="daily", title="<summary>", content="<details>", tags=[])
+- Use kind="concept" for reusable knowledge.
+```
+
+#### Approach 2: Hooks (automatic, no prompt engineering needed)
+
+Hooks run shell commands at specific lifecycle points — no instructions needed, they fire deterministically. **⚠️ Not tested with DuckBrain yet.**
+
+**Claude Code** — supports a full [hooks system](https://code.claude.com/docs/en/hooks) including `SessionEnd` (fires when a session terminates). Add to `.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "SessionEnd": [
+      {
+        "type": "command",
+        "command": "duckbrain-save-session --transcript-from-stdin"
+      }
+    ]
+  }
+}
+```
+
+The `SessionEnd` hook receives the full transcript on stdin. A wrapper script could pipe it through an LLM to extract learnings, then call `vault_write`. See [`agent-memory-mcp`](https://github.com/ipiton/agent-memory-mcp) for a production example of this pattern.
+
+**Cursor** — supports [hooks](https://cursor.com/docs/hooks.md) including `sessionEnd`, `postToolUse`, and `stop` via `.cursor/hooks.json`. However, `sessionEnd` is **not available in cloud agents** (local IDE only), and MCP execution hooks (`beforeMCPExecution`/`afterMCPExecution`) are **not yet wired for cloud agents**. Usable for local development, not for cloud-based Cursor sessions.
+
+**.cursor/hooks.json** (local IDE only):
+```json
+{
+  "hooks": {
+    "stop": [
+      {
+        "type": "command",
+        "command": "duckbrain-save-session --reason stop"
+      }
+    ]
+  }
+}
+```
+
+### How It Works
+
+During a session, the agent encounters a problem, debugs it, and resolves it:
+
+```
+> vault_search("duckbrain daily write")
+> vault_read(filepath="wiki/...")
+
+Agent debugs, fixes, learns something...
+
+> vault_write(
+    kind="daily",
+    title="vault_write daily kind doesn't support filepath-based reads",
+    content="When vault_search returns filepaths, the agent may try to Read files
+    directly. vault_read should accept filepath as well as title to close this gap.",
+    tags=["duckbrain", "debugging", "learned"]
+  )
+```
+
+The learning is now in `daily/2026-05-28.md`. Tomorrow when you ask "how do I read vault pages by path?", the agent searches the vault, finds your note, and recalls the solution.
+
+## Tools
+
+### `vault_info`
+
+Get a summary of your vault's structure.
+
+```
+> vault_info()
+→ {
+    entities: 38,
+    concepts: 38,
+    sources: 33,
+    synthesis: 9,
+    available_tags: ["agent-memory", "ai", "duckdb", "mcp", ...],
+    last_modified: "2026-05-28"
+  }
+```
+
+No parameters. Useful for agents to discover what's in the vault before searching.
+
+### `vault_search`
+
+Full-text search over all wiki pages.
+
+```
+> vault_search("agent memory", kind="concept")
+→ [
+    { title: "Agent Memory Systems", kind: "concept",
+      filepath: "wiki/concepts/agent-memory-systems.md",
+      snippet: "A 6-level taxonomy of Claude Code memory approaches..." },
+    ...
+  ]
+```
+
+Parameters:
+- `query` (required) — search text, BM25-ranked
+- `kind` (optional) — filter to `entity`, `concept`, `source`, `synthesis`, or `daily`
+- `tags` (optional) — filter by tag substring matches
+
+### `vault_read`
+
+Read a page by title or filepath. Returns full markdown content with metadata.
+
+```
+> vault_read(title="Agent Memory Systems")
+→ {
+    title: "Agent Memory Systems", kind: "concept",
+    filepath: "wiki/concepts/agent-memory-systems.md",
+    content: "# Agent Memory Systems\n\nA 6-level taxonomy...",
+    tags: ["agent-memory", "taxonomy", "ai"],
+    created: "2026-05-28", updated: "2026-05-28"
+  }
+```
+
+Parameters:
+- `title` (optional) — page title to look up (case-insensitive)
+- `filepath` (optional) — relative path from vault_search results (e.g. `wiki/concepts/foo.md`)
+
+Use after `vault_search` to get full page content. Pass `filepath` from search results directly.
+
+### `vault_write`
+
+Create a new wiki page or append to today's daily note, with automatic index and log updates.
+
+```
+> vault_write(
+    kind="concept",
+    title="DuckDB FTS Memory",
+    content="# DuckDB FTS Memory\n\nHow DuckDB serves as a memory layer...",
+    tags=["agent-memory", "duckdb"]
+  )
+→ { success: true, filepath: "wiki/concepts/duckdb-fts-memory.md" }
+```
+
+For daily notes (session learnings, debugging logs):
+```
+> vault_write(
+    kind="daily",
+    title="Debugging vault_read filepath",
+    content="When search returns filepaths, agents try to Read files directly.",
+    tags=["duckbrain", "debugging"]
+  )
+→ { success: true, filepath: "daily/2026-05-28.md" }
+```
+
+For wiki pages (entity|concept|source|synthesis), this automatically:
+1. Writes the markdown file to the correct wiki subdirectory
+2. Generates YAML frontmatter with title, item-type, tags, dates
+3. Appends an entry to `wiki/index.md` in the right section
+4. Appends a dated entry to `wiki/log.md`
+
+For daily notes, this automatically:
+1. Appends to `daily/YYYY-MM-DD.md` (creates the file if today's doesn't exist yet)
+2. No YAML frontmatter — just a `## heading` + content
+3. Does NOT update index.md (daily notes aren't wiki pages)
+4. Appends a dated entry to `wiki/log.md`
+
+Parameters:
+- `kind` (required) — `entity`, `concept`, `source`, `synthesis`, or `daily`
+- `title` (required) — page title (or section heading for daily entries)
+- `content` (required) — markdown body (without frontmatter)
+- `tags` (required) — list of tag strings
+
+## Vault Path
+
+Set via the `VAULT_PATH` environment variable (or the `env` field in your MCP config — no need for both). 
+
+For local development, copy `.env.example` to `.env` and set your path:
+
+```
+VAULT_PATH=/path/to/your/obsidian/vault
+```
+
+If you use WSL2 with your vault on Windows, set it to the WSL mount path (e.g., `/mnt/c/Users/you/Documents/obsidian/my-vault`).
+
+## Performance
+
+- FTS index rebuilt fresh from disk on every query — ~90 pages in under a second
+- Write operations complete in <500ms
+- Everything is in-memory — no persistent DuckDB database file
+- Zero network calls, zero external services
+
+## Limitations (v1)
+
+- No update or delete operations (only create)
+- No vector embeddings or semantic search
+- No page deduplication check before writing
+- ~1s per search at current scale; at 500+ pages, incremental indexing would be needed
+
+## Under Consideration
+
+Ideas we're exploring but not committing to yet — as we use the tool and understand what matters, some of these may get built. Open an issue to discuss.
+
+- **Temporal decay (recency bias)** — boost search results from recently created or updated pages. Older knowledge fades unless explicitly referenced.
+- **Vector embeddings / semantic search** — cover the ~20% recall gap that BM25 can't reach (concepts with different wording). Could integrate MemSearch or local embeddings.
+- **Update and delete operations** — allow agents to edit or remove existing pages, not just create.
+- **Incremental indexing** — INSERT single pages into the FTS index instead of full rebuild, keeping search fast at 500+ pages.
+- **Page deduplication** — detect when a page with the same title already exists before writing.
+
+## Inspirations
+
+This project stands on the shoulders of several ideas and tools:
+
+- **[Andrej Karpathy's LLM wiki pattern](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f)** — the idea that a personal markdown wiki, co-maintained by humans and AI agents, compounds into a persistent knowledge base. The vault schema (entities, concepts, sources, synthesis, daily log) is directly inspired by this.
+- **[DuckDB](https://duckdb.org/)** — the embedded analytical database that makes full-text search over flat files viable without a server, index sync, or persistent storage. The decision to use in-memory FTS instead of a vector database was a deliberate trade-off for simplicity.
+- **[Obsidian](https://obsidian.md/)** — the local-first, markdown-native note-taking tool that treats your files as the truth. DuckBrain exists because Obsidian vaults deserve tooling that respects the filesystem.
+- **[MemSearch](https://github.com/zilliztech/memsearch)** and **[Open Brain (OB1)](https://github.com/NateBJones-Projects/OB1)** — early experiments in cross-tool agent memory that demonstrated the *need* for structured vault write-back while choosing different architectures. Their strengths and gaps directly informed DuckBrain's design.
+- **[Agent Memory Systems (6-level taxonomy)](https://www.youtube.com/watch?v=UHVFcUzAGlM)** — Simon Scrapes' comprehensive comparison of Claude Code memory approaches provided the framework for understanding where DuckBrain fits in the ecosystem (Level 6: cross-tool MCP with dedicated server).
+- **[trellis-datamodel](https://github.com/timhiebenthal/trellis-datamodel)** — the same author's data modeling tool whose CI/CD patterns were borrowed for this project's repository readiness.
+- **[mondayDB 3 — Solving HTAP for a Trillion-Table System](https://engineering.monday.com/mondaydb-3-solving-htap-for-a-trillion-table-system/)** — monday.com's engineering blog on their DuckDB-powered CQRS read serving layer at production scale. Proved that DuckDB in-process with per-tenant file isolation is a viable architecture — the same pattern DuckBrain applies at personal-wiki scale.
+
+The core decision — **build, don't integrate** — came from a [structured comparison](https://github.com/timhiebenthal/duckbrain/blob/main/specs/2026-05-28-duckdb-memory-mcp/spec.md) of 7 existing tools. All failed on one requirement: vault schema-aware write-back. Rather than fork or extend, DuckBrain started from first principles: what's the simplest thing that gives agents structured read/write access to an Obsidian vault? The answer was DuckDB + MCP + ~500 lines of Python.
+
+## License
+
+MIT

duckbrain-0.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+duckbrain/__init__.py,sha256=Fu9Cwe6oZCrwzeNnm1UaiGdDzt4XH0_vbytUtccJhFc,819
+duckbrain/indexer.py,sha256=xVgIY-OcPIHigOIR2KOmAKbkialA77djXZrpsOP-zPs,5193
+duckbrain/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+duckbrain/scanner.py,sha256=PqqMK5y3LHU3LdXPpPVzwneAnl8UCvvQb_9npH7OE8I,4145
+duckbrain/server.py,sha256=LItGZaMqhxJeHTcC2ZAGDBmTgrDCgHaqXRMyJNaBvHo,3257
+duckbrain/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+duckbrain/tools/vault_info.py,sha256=PQgLYOxasjBT9YQmqz3LZ95_LcQEdr6tDm4u1_no73g,863
+duckbrain/tools/vault_read.py,sha256=7uqlJH0D8goQE0Vl3PIv_-ceEbjcrAvTbzAAK_DJsLw,2528
+duckbrain/tools/vault_search.py,sha256=jxb8QLZRUSu_Kxfut7q5EWr-S7wzuuy6Qndg5MWmdxE,988
+duckbrain/tools/vault_write.py,sha256=I5Wuwq6iFKk7LZdk4iDJEav3Ncz6cbPyy5v6s_2A2Jg,929
+duckbrain/writer.py,sha256=_Rv7F-Is0_MEF6K0yPDlTXczq_4-tKhP9EdnyyOM-dM,8015
+duckbrain-0.1.1.dist-info/WHEEL,sha256=Q9FtwzuR2QE37l-JIkuyklGnJJiCBHKnsPVQ9vzCMzQ,81
+duckbrain-0.1.1.dist-info/entry_points.txt,sha256=-MOROdOKLzKmDigdJ5P8A1hY27YosisP1Yng4ld0rk4,53
+duckbrain-0.1.1.dist-info/METADATA,sha256=z5FHLKJoijcOgYgXVqKhcgZjabm-QZYBXMJWGtTEDeI,21044
+duckbrain-0.1.1.dist-info/RECORD,,

duckbrain-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.17
+Root-Is-Purelib: true
+Tag: py3-none-any

duckbrain-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+duckbrain = duckbrain.server:main
+