brainlayer 1.0.0__py3-none-any.whl

brainlayer/cli/wizard.py

@@ -0,0 +1,132 @@
+"""Interactive setup wizard for BrainLayer.
+
+Detects the user's environment, recommends configuration,
+and guides through first-time setup.
+"""
+
+import platform
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class WizardConfig:
+    """Configuration generated by the wizard."""
+
+    enrich_backend: str = "none"
+    extras: list[str] = field(default_factory=list)
+    claude_projects_dir: Optional[Path] = None
+    db_path: Optional[Path] = None
+
+
+def detect_environment() -> dict:
+    """Detect available tools and data sources."""
+    env = {}
+
+    # Check Ollama
+    env["ollama_available"] = shutil.which("ollama") is not None
+    if env["ollama_available"]:
+        try:
+            result = subprocess.run(["ollama", "list"], capture_output=True, text=True, timeout=5)
+            env["ollama_models"] = result.stdout.strip().split("\n") if result.returncode == 0 else []
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            env["ollama_available"] = False
+            env["ollama_models"] = []
+    else:
+        env["ollama_models"] = []
+
+    # Check Apple Silicon (for MLX)
+    env["is_apple_silicon"] = platform.system() == "Darwin" and platform.machine() == "arm64"
+
+    # Check Claude Code conversations
+    claude_dir = Path.home() / ".claude" / "projects"
+    env["claude_projects_dir"] = claude_dir if claude_dir.exists() else None
+    env["conversation_count"] = len(list(claude_dir.rglob("*.jsonl"))) if claude_dir.exists() else 0
+
+    # Check for WhatsApp exports
+    env["whatsapp_available"] = False
+
+    # Check for existing DB
+    default_db = Path.home() / ".local" / "share" / "brainlayer" / "brainlayer.db"
+    env["existing_db"] = default_db.exists()
+
+    return env
+
+
+def run_wizard() -> WizardConfig:
+    """Run the interactive setup wizard. Returns configuration."""
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.prompt import Confirm, Prompt
+
+    console = Console()
+    config = WizardConfig()
+
+    console.print(
+        Panel.fit(
+            "[bold]BrainLayer Setup Wizard[/bold]\nLike git for your AI conversations.",
+            border_style="blue",
+        )
+    )
+
+    console.print("\n[dim]Detecting your environment...[/dim]")
+    env = detect_environment()
+
+    console.print(f"\n  Claude Code conversations: [green]{env['conversation_count']}[/green] JSONL files")
+    console.print(
+        f"  Ollama: {'[green]available[/green]' if env['ollama_available'] else '[yellow]not found[/yellow]'}"
+    )
+    console.print(f"  Apple Silicon (MLX): {'[green]yes[/green]' if env['is_apple_silicon'] else '[dim]no[/dim]'}")
+    console.print(f"  Existing DB: {'[green]found[/green]' if env['existing_db'] else '[dim]none[/dim]'}")
+
+    if env["is_apple_silicon"] and env["ollama_available"]:
+        backend = Prompt.ask(
+            "\nEnrichment backend",
+            choices=["ollama", "mlx", "none"],
+            default="ollama",
+        )
+    elif env["ollama_available"]:
+        backend = Prompt.ask(
+            "\nEnrichment backend",
+            choices=["ollama", "none"],
+            default="ollama",
+        )
+    else:
+        console.print("\n[yellow]No local LLM found. Enrichment disabled.[/yellow]")
+        console.print("[dim]Install Ollama (ollama.ai) for local enrichment.[/dim]")
+        backend = "none"
+    config.enrich_backend = backend
+
+    extras = []
+    if Confirm.ask("\nInstall style analysis (communication patterns)?", default=False):
+        extras.append("style")
+    if Confirm.ask("Install YouTube transcript indexing?", default=False):
+        extras.append("youtube")
+    if Confirm.ask("Install Obsidian export?", default=False):
+        extras.append("obsidian")
+    config.extras = extras
+
+    if env["claude_projects_dir"]:
+        config.claude_projects_dir = env["claude_projects_dir"]
+    else:
+        custom = Prompt.ask(
+            "Path to Claude Code projects directory",
+            default=str(Path.home() / ".claude" / "projects"),
+        )
+        config.claude_projects_dir = Path(custom)
+
+    console.print(
+        Panel.fit(
+            f"[bold green]Setup complete![/bold green]\n\n"
+            f"  Backend: {config.enrich_backend}\n"
+            f"  Extras: {', '.join(config.extras) or 'none'}\n"
+            f"  Source: {config.claude_projects_dir}\n\n"
+            f"Run [bold]brainlayer index[/bold] to index your conversations.",
+            border_style="green",
+        )
+    )
+
+    return config

brainlayer/cli_new.py

@@ -0,0 +1,151 @@
+"""Updated CLI commands using daemon client."""
+
+from pathlib import Path
+
+import typer
+from rich import print as rprint
+from rich.console import Console
+from rich.table import Table
+
+from .client import get_client
+
+console = Console()
+
+
+def search_command(
+    query: str = typer.Argument(..., help="Search query"),
+    n: int = typer.Option(5, "--num", "-n", help="Number of results", min=1, max=100),
+    project: str = typer.Option(None, "--project", "-p", help="Filter by project"),
+    content_type: str = typer.Option(None, "--type", "-t", help="Filter by content type"),
+    text: bool = typer.Option(False, "--text", help="Use text-based search instead of semantic search"),
+    hybrid: bool = True,
+) -> None:
+    """Search the knowledge base using fast daemon."""
+    try:
+        # Auto-detect domain-like queries and use text search
+        if not text and ("." in query or query.startswith("http") or "/" in query):
+            text = True
+            rprint("[dim]Auto-detected domain/URL query, using text search[/]")
+
+        search_type = "text" if text else ("hybrid" if hybrid else "semantic")
+        rprint(f"[bold blue]זיכרון[/] - Searching ({search_type}): [italic]{query}[/]")
+
+        # Search using daemon
+        client = get_client()
+
+        with console.status("[bold green]Searching..."):
+            results = client.search(
+                query=query,
+                n_results=n,
+                project_filter=project,
+                content_type_filter=content_type,
+                use_semantic=not text,
+                hybrid=hybrid and not text,
+            )
+
+        # Display results
+        if not results["documents"]:
+            rprint("[yellow]No results found[/]")
+            return
+
+        search_time = results["total_time_ms"]
+        rprint(f"[dim]Found {len(results['documents'])} results in {search_time:.1f}ms[/]\n")
+
+        result_ids = results.get("ids", [])
+        for i, (doc, meta, dist) in enumerate(zip(results["documents"], results["metadatas"], results["distances"])):
+            score = 1 - dist if dist is not None else None
+            score_str = f"[dim](score: {score:.3f})[/]" if score is not None else "[dim](text match)[/]"
+            proj = _clean_project_name(meta.get("project", "unknown"))
+            # Show contact name for WhatsApp/messaging sources
+            if proj == "unknown" and meta.get("contact_name"):
+                proj = meta["contact_name"]
+            chunk_id = result_ids[i] if i < len(result_ids) else None
+
+            # Truncate long content
+            content = doc[:500] + "..." if len(doc) > 500 else doc
+
+            rprint(f"[bold cyan]{i + 1}.[/] {score_str} [dim]({proj})[/]")
+            rprint(f"[white]{content}[/]")
+            if chunk_id:
+                rprint(f"[dim]ID: {chunk_id}[/]")
+            rprint()
+
+    except Exception as e:
+        rprint(f"[bold red]Error:[/] {e}")
+        raise typer.Exit(1)
+
+
+def stats_command() -> None:
+    """Show knowledge base statistics."""
+    try:
+        client = get_client()
+
+        with console.status("[bold green]Getting stats..."):
+            stats = client.get_stats()
+
+        rprint("[bold blue]זיכרון[/] - Knowledge Base Statistics\n")
+
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", style="white")
+
+        table.add_row("Total Chunks", f"{stats['total_chunks']:,}")
+        table.add_row("Projects", str(len(stats["projects"])))
+        table.add_row("Content Types", str(len(stats["content_types"])))
+
+        console.print(table)
+
+        if stats["projects"]:
+            rprint(f"\n[bold]Projects:[/] {', '.join(stats['projects'])}")
+
+        if stats["content_types"]:
+            rprint(f"[bold]Content Types:[/] {', '.join(stats['content_types'])}")
+
+    except Exception as e:
+        rprint(f"[bold red]Error:[/] {e}")
+        raise typer.Exit(1)
+
+
+def migrate_command() -> None:
+    """Migrate from ChromaDB to sqlite-vec."""
+    try:
+        from .migrate import migrate_from_chromadb
+
+        rprint("[bold blue]זיכרון[/] - Migration Tool\n")
+
+        sqlite_path = Path.home() / ".local" / "share" / "brainlayer" / "brainlayer.db"
+
+        if sqlite_path.exists():
+            response = typer.confirm("sqlite-vec database already exists. Overwrite?")
+            if not response:
+                rprint("Migration cancelled")
+                return
+            sqlite_path.unlink()
+
+        with console.status("[bold green]Migrating data..."):
+            success = migrate_from_chromadb()
+
+        if success:
+            rprint("[bold green]✓[/] Migration completed successfully!")
+            rprint("You can now use the fast daemon service.")
+        else:
+            rprint("[bold red]✗[/] Migration failed or skipped")
+            raise typer.Exit(1)
+
+    except Exception as e:
+        rprint(f"[bold red]Error:[/] {e}")
+        raise typer.Exit(1)
+
+
+def _clean_project_name(project: str) -> str:
+    """Clean project name for display."""
+    if not project or project == "unknown":
+        return "unknown"
+
+    # Remove common prefixes
+    if project.startswith("/Users/"):
+        parts = project.split("/")
+        if len(parts) > 4:
+            return "/".join(parts[-2:])  # Last two parts
+
+    return project

brainlayer/client.py

@@ -0,0 +1,164 @@
+"""Client for communicating with brainlayer daemon."""
+
+import logging
+import subprocess
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+SOCKET_PATH = Path("/tmp/brainlayer.sock")
+DAEMON_STARTUP_TIMEOUT = 30  # seconds
+
+
+class DaemonClient:
+    """Client for brainlayer daemon."""
+
+    def __init__(self):
+        self.base_url = "http://localhost"
+        self._client: Optional[httpx.Client] = None
+
+    def _get_client(self) -> httpx.Client:
+        """Get HTTP client with Unix socket transport."""
+        if self._client is None:
+            transport = httpx.HTTPTransport(uds=str(SOCKET_PATH))
+            self._client = httpx.Client(base_url=self.base_url, transport=transport, timeout=30.0)
+        return self._client
+
+    def _is_daemon_running(self) -> bool:
+        """Check if daemon is running."""
+        if not SOCKET_PATH.exists():
+            return False
+
+        try:
+            client = self._get_client()
+            response = client.get("/health")
+            return response.status_code == 200
+        except Exception:
+            return False
+
+    def _start_daemon(self) -> bool:
+        """Start daemon process."""
+        try:
+            # Start daemon in background
+            subprocess.Popen(
+                ["brainlayer-daemon"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+
+            # Wait for daemon to start
+            for _ in range(DAEMON_STARTUP_TIMEOUT):
+                if self._is_daemon_running():
+                    return True
+                time.sleep(1)
+
+            return False
+
+        except Exception as e:
+            logger.warning("Failed to start daemon: %s", e)
+            return False
+
+    def _ensure_daemon(self) -> bool:
+        """Ensure daemon is running."""
+        if self._is_daemon_running():
+            return True
+
+        logger.info("Starting brainlayer daemon...")
+        return self._start_daemon()
+
+    def search(
+        self,
+        query: str,
+        n_results: int = 10,
+        project_filter: Optional[str] = None,
+        content_type_filter: Optional[str] = None,
+        source_filter: Optional[str] = None,
+        use_semantic: bool = True,
+        hybrid: bool = True,
+    ) -> Dict[str, Any]:
+        """Search the knowledge base."""
+        if not self._ensure_daemon():
+            raise RuntimeError("Failed to start daemon")
+
+        try:
+            client = self._get_client()
+            response = client.post(
+                "/search",
+                json={
+                    "query": query,
+                    "n_results": n_results,
+                    "project_filter": project_filter,
+                    "content_type_filter": content_type_filter,
+                    "source_filter": source_filter,
+                    "use_semantic": use_semantic,
+                    "hybrid": hybrid,
+                },
+            )
+            response.raise_for_status()
+            return response.json()
+
+        except httpx.RequestError as e:
+            raise RuntimeError(f"Failed to communicate with daemon: {e}")
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"Search failed: {e.response.text}")
+
+    def get_context(self, chunk_id: str, before: int = 3, after: int = 3) -> Dict[str, Any]:
+        """Get surrounding conversation context for a chunk."""
+        if not self._ensure_daemon():
+            raise RuntimeError("Failed to start daemon")
+
+        try:
+            client = self._get_client()
+            response = client.get(f"/context/{chunk_id}", params={"before": before, "after": after})
+            response.raise_for_status()
+            return response.json()
+
+        except httpx.RequestError as e:
+            raise RuntimeError(f"Failed to communicate with daemon: {e}")
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"Context request failed: {e.response.text}")
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get collection statistics."""
+        if not self._ensure_daemon():
+            raise RuntimeError("Failed to start daemon")
+
+        try:
+            client = self._get_client()
+            response = client.get("/stats")
+            response.raise_for_status()
+            return response.json()
+
+        except httpx.RequestError as e:
+            raise RuntimeError(f"Failed to communicate with daemon: {e}")
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"Stats request failed: {e.response.text}")
+
+    def close(self):
+        """Close client connection."""
+        if self._client:
+            self._client.close()
+            self._client = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+# Global client instance
+_client: Optional[DaemonClient] = None
+
+
+def get_client() -> DaemonClient:
+    """Get global daemon client."""
+    global _client
+    if _client is None:
+        _client = DaemonClient()
+    return _client