mempalace-code 1.0.0__py3-none-any.whl

mempalace/palace_graph.py

@@ -0,0 +1,225 @@
+"""
+palace_graph.py — Graph traversal layer for MemPalace
+======================================================
+
+Builds a navigable graph from the palace structure:
+  - Nodes = rooms (named ideas)
+  - Edges = shared rooms across wings (tunnels)
+  - Edge types = halls (the corridors)
+
+Enables queries like:
+  "Start at chromadb-setup in wing_code, walk to wing_myproject"
+  "Find all rooms connected to riley-college-apps"
+  "What topics bridge wing_hardware and wing_myproject?"
+
+No external graph DB needed — built from ChromaDB metadata.
+"""
+
+from collections import defaultdict, Counter
+from .config import MempalaceConfig
+from .storage import open_store
+
+
+def _get_store(config=None):
+    config = config or MempalaceConfig()
+    try:
+        return open_store(config.palace_path, create=False)
+    except Exception:
+        return None
+
+
+def build_graph(col=None, config=None):
+    """
+    Build the palace graph from drawer metadata.
+
+    Returns:
+        nodes: dict of {room: {wings: set, halls: set, count: int}}
+        edges: list of {room, wing_a, wing_b, hall} — one per tunnel crossing
+    """
+    if col is None:
+        col = _get_store(config)
+    if not col:
+        return {}, []
+
+    total = col.count()
+    room_data = defaultdict(lambda: {"wings": set(), "halls": set(), "count": 0, "dates": set()})
+
+    offset = 0
+    while offset < total:
+        batch = col.get(limit=1000, offset=offset, include=["metadatas"])
+        for meta in batch["metadatas"]:
+            room = meta.get("room", "")
+            wing = meta.get("wing", "")
+            hall = meta.get("hall", "")
+            date = meta.get("date", "")
+            if room and room != "general" and wing:
+                room_data[room]["wings"].add(wing)
+                if hall:
+                    room_data[room]["halls"].add(hall)
+                if date:
+                    room_data[room]["dates"].add(date)
+                room_data[room]["count"] += 1
+        if not batch["ids"]:
+            break
+        offset += len(batch["ids"])
+
+    # Build edges from rooms that span multiple wings
+    edges = []
+    for room, data in room_data.items():
+        wings = sorted(data["wings"])
+        if len(wings) >= 2:
+            for i, wa in enumerate(wings):
+                for wb in wings[i + 1 :]:
+                    for hall in data["halls"]:
+                        edges.append(
+                            {
+                                "room": room,
+                                "wing_a": wa,
+                                "wing_b": wb,
+                                "hall": hall,
+                                "count": data["count"],
+                            }
+                        )
+
+    # Convert sets to lists for JSON serialization
+    nodes = {}
+    for room, data in room_data.items():
+        nodes[room] = {
+            "wings": sorted(data["wings"]),
+            "halls": sorted(data["halls"]),
+            "count": data["count"],
+            "dates": sorted(data["dates"])[-5:] if data["dates"] else [],
+        }
+
+    return nodes, edges
+
+
+def traverse(start_room: str, col=None, config=None, max_hops: int = 2):
+    """
+    Walk the graph from a starting room. Find connected rooms
+    through shared wings.
+
+    Returns list of paths: [{room, wing, hall, hop_distance}]
+    """
+    nodes, edges = build_graph(col, config)
+
+    if start_room not in nodes:
+        return {
+            "error": f"Room '{start_room}' not found",
+            "suggestions": _fuzzy_match(start_room, nodes),
+        }
+
+    start = nodes[start_room]
+    visited = {start_room}
+    results = [
+        {
+            "room": start_room,
+            "wings": start["wings"],
+            "halls": start["halls"],
+            "count": start["count"],
+            "hop": 0,
+        }
+    ]
+
+    # BFS traversal
+    frontier = [(start_room, 0)]
+    while frontier:
+        current_room, depth = frontier.pop(0)
+        if depth >= max_hops:
+            continue
+
+        current = nodes.get(current_room, {})
+        current_wings = set(current.get("wings", []))
+
+        # Find all rooms that share a wing with current room
+        for room, data in nodes.items():
+            if room in visited:
+                continue
+            shared_wings = current_wings & set(data["wings"])
+            if shared_wings:
+                visited.add(room)
+                results.append(
+                    {
+                        "room": room,
+                        "wings": data["wings"],
+                        "halls": data["halls"],
+                        "count": data["count"],
+                        "hop": depth + 1,
+                        "connected_via": sorted(shared_wings),
+                    }
+                )
+                if depth + 1 < max_hops:
+                    frontier.append((room, depth + 1))
+
+    # Sort by relevance (hop distance, then count)
+    results.sort(key=lambda x: (x["hop"], -x["count"]))
+    return results[:50]  # cap results
+
+
+def find_tunnels(wing_a: str = None, wing_b: str = None, col=None, config=None):
+    """
+    Find rooms that connect two wings (or all tunnel rooms if no wings specified).
+    These are the "hallways" — same named idea appearing in multiple domains.
+    """
+    nodes, edges = build_graph(col, config)
+
+    tunnels = []
+    for room, data in nodes.items():
+        wings = data["wings"]
+        if len(wings) < 2:
+            continue
+
+        if wing_a and wing_a not in wings:
+            continue
+        if wing_b and wing_b not in wings:
+            continue
+
+        tunnels.append(
+            {
+                "room": room,
+                "wings": wings,
+                "halls": data["halls"],
+                "count": data["count"],
+                "recent": data["dates"][-1] if data["dates"] else "",
+            }
+        )
+
+    tunnels.sort(key=lambda x: -x["count"])
+    return tunnels[:50]
+
+
+def graph_stats(col=None, config=None):
+    """Summary statistics about the palace graph."""
+    nodes, edges = build_graph(col, config)
+
+    tunnel_rooms = sum(1 for n in nodes.values() if len(n["wings"]) >= 2)
+    wing_counts = Counter()
+    for data in nodes.values():
+        for w in data["wings"]:
+            wing_counts[w] += 1
+
+    return {
+        "total_rooms": len(nodes),
+        "tunnel_rooms": tunnel_rooms,
+        "total_edges": len(edges),
+        "rooms_per_wing": dict(wing_counts.most_common()),
+        "top_tunnels": [
+            {"room": r, "wings": d["wings"], "count": d["count"]}
+            for r, d in sorted(nodes.items(), key=lambda x: -len(x[1]["wings"]))[:10]
+            if len(d["wings"]) >= 2
+        ],
+    }
+
+
+def _fuzzy_match(query: str, nodes: dict, n: int = 5):
+    """Find rooms that approximately match a query string."""
+    query_lower = query.lower()
+    scored = []
+    for room in nodes:
+        # Simple substring matching
+        if query_lower in room:
+            scored.append((room, 1.0))
+        elif any(word in room for word in query_lower.split("-")):
+            scored.append((room, 0.5))
+    scored.sort(key=lambda x: -x[1])
+    return [r for r, _ in scored[:n]]

mempalace/room_detector_local.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""
+room_detector_local.py — Local setup, no API required.
+
+Two ways to define rooms without calling any AI:
+  1. Auto-detect from folder structure (zero config)
+  2. Define manually in mempalace.yaml
+
+No internet. No API key. Your files stay on your machine.
+"""
+
+import os
+import sys
+import yaml
+from pathlib import Path
+from collections import defaultdict
+
+# Common room patterns — detected from folder names and filenames
+# Format: {folder_keyword: room_name}
+FOLDER_ROOM_MAP = {
+    "frontend": "frontend",
+    "front-end": "frontend",
+    "front_end": "frontend",
+    "client": "frontend",
+    "ui": "frontend",
+    "views": "frontend",
+    "components": "frontend",
+    "pages": "frontend",
+    "backend": "backend",
+    "back-end": "backend",
+    "back_end": "backend",
+    "server": "backend",
+    "api": "backend",
+    "routes": "backend",
+    "services": "backend",
+    "controllers": "backend",
+    "models": "backend",
+    "database": "backend",
+    "db": "backend",
+    "docs": "documentation",
+    "doc": "documentation",
+    "documentation": "documentation",
+    "wiki": "documentation",
+    "readme": "documentation",
+    "notes": "documentation",
+    "design": "design",
+    "designs": "design",
+    "mockups": "design",
+    "wireframes": "design",
+    "assets": "design",
+    "storyboard": "design",
+    "costs": "costs",
+    "cost": "costs",
+    "budget": "costs",
+    "finance": "costs",
+    "financial": "costs",
+    "pricing": "costs",
+    "invoices": "costs",
+    "accounting": "costs",
+    "meetings": "meetings",
+    "meeting": "meetings",
+    "calls": "meetings",
+    "meeting_notes": "meetings",
+    "standup": "meetings",
+    "minutes": "meetings",
+    "team": "team",
+    "staff": "team",
+    "hr": "team",
+    "hiring": "team",
+    "employees": "team",
+    "people": "team",
+    "research": "research",
+    "references": "research",
+    "reading": "research",
+    "papers": "research",
+    "planning": "planning",
+    "roadmap": "planning",
+    "strategy": "planning",
+    "specs": "planning",
+    "requirements": "planning",
+    "tests": "testing",
+    "test": "testing",
+    "testing": "testing",
+    "qa": "testing",
+    "scripts": "scripts",
+    "tools": "scripts",
+    "utils": "scripts",
+    "config": "configuration",
+    "configs": "configuration",
+    "settings": "configuration",
+    "infrastructure": "configuration",
+    "infra": "configuration",
+    "deploy": "configuration",
+}
+
+
+def detect_rooms_from_folders(project_dir: str) -> list:
+    """
+    Walk the project folder structure.
+    Find top-level subdirectories that match known room patterns.
+    Returns list of room dicts.
+    """
+    project_path = Path(project_dir).expanduser().resolve()
+    found_rooms = {}
+
+    SKIP_DIRS = {
+        ".git",
+        "node_modules",
+        "__pycache__",
+        ".venv",
+        "venv",
+        "env",
+        "dist",
+        "build",
+        ".next",
+        "coverage",
+    }
+
+    # Check top-level directories first (most reliable signal)
+    for item in project_path.iterdir():
+        if item.is_dir() and item.name not in SKIP_DIRS:
+            name_lower = item.name.lower().replace("-", "_")
+            if name_lower in FOLDER_ROOM_MAP:
+                room_name = FOLDER_ROOM_MAP[name_lower]
+                if room_name not in found_rooms:
+                    found_rooms[room_name] = item.name
+            # Also check if folder name IS a good room name directly
+            elif len(item.name) > 2 and item.name[0].isalpha():
+                clean = item.name.lower().replace("-", "_").replace(" ", "_")
+                if clean not in found_rooms:
+                    found_rooms[clean] = item.name
+
+    # Walk one level deeper for nested patterns
+    for item in project_path.iterdir():
+        if item.is_dir() and item.name not in SKIP_DIRS:
+            for subitem in item.iterdir():
+                if subitem.is_dir() and subitem.name not in SKIP_DIRS:
+                    name_lower = subitem.name.lower().replace("-", "_")
+                    if name_lower in FOLDER_ROOM_MAP:
+                        room_name = FOLDER_ROOM_MAP[name_lower]
+                        if room_name not in found_rooms:
+                            found_rooms[room_name] = subitem.name
+
+    # Build room list
+    rooms = []
+    for room_name, original in found_rooms.items():
+        rooms.append(
+            {
+                "name": room_name,
+                "description": f"Files from {original}/",
+                "keywords": [room_name, original.lower()],
+            }
+        )
+
+    # Always add "general" as fallback
+    if not any(r["name"] == "general" for r in rooms):
+        rooms.append(
+            {
+                "name": "general",
+                "description": "Files that don't fit other rooms",
+                "keywords": [],
+            }
+        )
+
+    return rooms
+
+
+def detect_rooms_from_files(project_dir: str) -> list:
+    """
+    Fallback: if folder structure gives no signal,
+    detect rooms from recurring filename patterns.
+    """
+    project_path = Path(project_dir).expanduser().resolve()
+    keyword_counts = defaultdict(int)
+
+    SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", "dist", "build"}
+
+    for root, dirs, filenames in os.walk(project_path):
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
+        for filename in filenames:
+            name_lower = filename.lower().replace("-", "_").replace(" ", "_")
+            for keyword, room in FOLDER_ROOM_MAP.items():
+                if keyword in name_lower:
+                    keyword_counts[room] += 1
+
+    # Return rooms that appear more than twice
+    rooms = []
+    for room, count in sorted(keyword_counts.items(), key=lambda x: x[1], reverse=True):
+        if count >= 2:
+            rooms.append(
+                {
+                    "name": room,
+                    "description": f"Files related to {room}",
+                    "keywords": [room],
+                }
+            )
+        if len(rooms) >= 6:
+            break
+
+    if not rooms:
+        rooms = [{"name": "general", "description": "All project files", "keywords": []}]
+
+    return rooms
+
+
+def print_proposed_structure(project_name: str, rooms: list, total_files: int, source: str):
+    print(f"\n{'=' * 55}")
+    print("  MemPalace Init — Local setup")
+    print(f"{'=' * 55}")
+    print(f"\n  WING: {project_name}")
+    print(f"  ({total_files} files found, rooms detected from {source})\n")
+    for room in rooms:
+        print(f"    ROOM: {room['name']}")
+        print(f"          {room['description']}")
+    print(f"\n{'─' * 55}")
+
+
+def get_user_approval(rooms: list) -> list:
+    """Same approval flow as AI version."""
+    print("  Review the proposed rooms above.")
+    print("  Options:")
+    print("    [enter]  Accept all rooms")
+    print("    [edit]   Remove or rename rooms")
+    print("    [add]    Add a room manually")
+    print()
+
+    choice = input("  Your choice [enter/edit/add]: ").strip().lower()
+
+    if choice in ("", "y", "yes"):
+        return rooms
+
+    if choice == "edit":
+        print("\n  Current rooms:")
+        for i, room in enumerate(rooms):
+            print(f"    {i + 1}. {room['name']} — {room['description']}")
+        remove = input("\n  Room numbers to REMOVE (comma-separated, or enter to skip): ").strip()
+        if remove:
+            to_remove = {int(x.strip()) - 1 for x in remove.split(",") if x.strip().isdigit()}
+            rooms = [r for i, r in enumerate(rooms) if i not in to_remove]
+
+    if choice == "add" or input("\n  Add any missing rooms? [y/N]: ").strip().lower() == "y":
+        while True:
+            new_name = (
+                input("  New room name (or enter to stop): ").strip().lower().replace(" ", "_")
+            )
+            if not new_name:
+                break
+            new_desc = input(f"  Description for '{new_name}': ").strip()
+            rooms.append({"name": new_name, "description": new_desc, "keywords": [new_name]})
+            print(f"  Added: {new_name}")
+
+    return rooms
+
+
+def save_config(project_dir: str, project_name: str, rooms: list):
+    config = {
+        "wing": project_name,
+        "rooms": [
+            {
+                "name": r["name"],
+                "description": r["description"],
+                "keywords": r.get("keywords", [r["name"]]),
+            }
+            for r in rooms
+        ],
+    }
+    config_path = Path(project_dir).expanduser().resolve() / "mempalace.yaml"
+    with open(config_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+    print(f"\n  Config saved: {config_path}")
+    print("\n  Next step:")
+    print(f"    mempalace mine {project_dir}")
+    print(f"\n{'=' * 55}\n")
+
+
+def detect_rooms_local(project_dir: str, yes: bool = False):
+    """Main entry point for local setup."""
+    project_path = Path(project_dir).expanduser().resolve()
+    project_name = project_path.name.lower().replace(" ", "_").replace("-", "_")
+
+    if not project_path.exists():
+        print(f"ERROR: Directory not found: {project_dir}")
+        sys.exit(1)
+
+    # Count files
+    from .miner import scan_project
+
+    files = scan_project(project_dir)
+
+    # Try folder structure first
+    rooms = detect_rooms_from_folders(project_dir)
+    source = "folder structure"
+
+    # If only "general" found, try filename patterns
+    if len(rooms) <= 1:
+        rooms = detect_rooms_from_files(project_dir)
+        source = "filename patterns"
+
+    # If still nothing, just use general
+    if not rooms:
+        rooms = [{"name": "general", "description": "All project files", "keywords": []}]
+        source = "fallback (flat project)"
+
+    print_proposed_structure(project_name, rooms, len(files), source)
+    if yes:
+        approved_rooms = rooms
+    else:
+        approved_rooms = get_user_approval(rooms)
+    save_config(project_dir, project_name, approved_rooms)