synaptiq 0.3.0__py3-none-any.whl

synaptiq/__init__.py

@@ -0,0 +1,3 @@
+"""Synaptiq — Graph-powered code intelligence engine."""
+
+__version__ = "0.3.0"

synaptiq/cli/__init__.py

@@ -0,0 +1 @@
+

synaptiq/cli/main.py

@@ -0,0 +1,475 @@
+"""Synaptiq CLI — Graph-powered code intelligence engine."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from synaptiq import __version__
+
+console = Console()
+
+def _load_storage(repo_path: Path | None = None) -> "KuzuBackend":  # noqa: F821
+    """Load the KuzuDB backend for the given or current repo."""
+    from synaptiq.core.storage.kuzu_backend import KuzuBackend
+
+    target = (repo_path or Path.cwd()).resolve()
+    db_path = target / ".synaptiq" / "kuzu"
+    if not db_path.exists():
+        console.print(
+            f"[red]Error:[/red] No index found at {target}. Run 'synaptiq analyze' first."
+        )
+        raise typer.Exit(code=1)
+
+    storage = KuzuBackend()
+    storage.initialize(db_path, read_only=True)
+    return storage
+
+app = typer.Typer(
+    name="synaptiq",
+    help="Synaptiq — Graph-powered code intelligence engine.",
+    no_args_is_help=True,
+)
+
+def _version_callback(value: bool) -> None:
+    """Print the version and exit."""
+    if value:
+        console.print(f"Synaptiq v{__version__}")
+        raise typer.Exit()
+
+@app.callback()
+def main(
+    version: Optional[bool] = typer.Option(  # noqa: N803
+        None,
+        "--version",
+        "-v",
+        help="Show version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """Synaptiq — Graph-powered code intelligence engine."""
+
+@app.command()
+def analyze(
+    path: Path = typer.Argument(Path("."), help="Path to the repository to index."),
+    full: bool = typer.Option(False, "--full", help="Perform a full re-index."),
+) -> None:
+    """Index a repository into a knowledge graph."""
+    from synaptiq.core.ingestion.pipeline import PipelineResult, run_pipeline
+    from synaptiq.core.storage.kuzu_backend import KuzuBackend
+
+    repo_path = path.resolve()
+    if not repo_path.is_dir():
+        console.print(f"[red]Error:[/red] {repo_path} is not a directory.")
+        raise typer.Exit(code=1)
+
+    console.print(f"[bold]Indexing[/bold] {repo_path}")
+
+    data_dir = repo_path / ".synaptiq"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    db_path = data_dir / "kuzu"
+
+    storage = KuzuBackend()
+    storage.initialize(db_path)
+
+    result: PipelineResult | None = None
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        task = progress.add_task("Starting...", total=None)
+
+        def on_progress(phase: str, pct: float) -> None:
+            progress.update(task, description=f"{phase} ({pct:.0%})")
+
+        _, result = run_pipeline(
+            repo_path=repo_path,
+            storage=storage,
+            full=full,
+            progress_callback=on_progress,
+        )
+
+    meta = {
+        "version": __version__,
+        "name": repo_path.name,
+        "path": str(repo_path),
+        "stats": {
+            "files": result.files,
+            "symbols": result.symbols,
+            "relationships": result.relationships,
+            "clusters": result.clusters,
+            "flows": result.processes,
+            "dead_code": result.dead_code,
+            "coupled_pairs": result.coupled_pairs,
+        },
+        "last_indexed_at": datetime.now(tz=timezone.utc).isoformat(),
+    }
+    meta_path = data_dir / "meta.json"
+    meta_path.write_text(json.dumps(meta, indent=2) + "\n", encoding="utf-8")
+
+    console.print()
+    console.print("[bold green]Indexing complete.[/bold green]")
+    console.print(f"  Files:          {result.files}")
+    console.print(f"  Symbols:        {result.symbols}")
+    console.print(f"  Relationships:  {result.relationships}")
+    if result.clusters > 0:
+        console.print(f"  Clusters:       {result.clusters}")
+    if result.processes > 0:
+        console.print(f"  Flows:          {result.processes}")
+    if result.dead_code > 0:
+        console.print(f"  Dead code:      {result.dead_code}")
+    if result.coupled_pairs > 0:
+        console.print(f"  Coupled pairs:  {result.coupled_pairs}")
+    console.print(f"  Duration:       {result.duration_seconds:.2f}s")
+
+    storage.close()
+
+@app.command()
+def status() -> None:
+    """Show index status for current repository."""
+    repo_path = Path.cwd().resolve()
+    meta_path = repo_path / ".synaptiq" / "meta.json"
+
+    if not meta_path.exists():
+        console.print(
+            f"[red]Error:[/red] No index found at {repo_path}. Run 'synaptiq analyze' first."
+        )
+        raise typer.Exit(code=1)
+
+    meta = json.loads(meta_path.read_text(encoding="utf-8"))
+    stats = meta.get("stats", {})
+
+    console.print(f"[bold]Index status for[/bold] {repo_path}")
+    console.print(f"  Version:        {meta.get('version', '?')}")
+    console.print(f"  Last indexed:   {meta.get('last_indexed_at', '?')}")
+    console.print(f"  Files:          {stats.get('files', '?')}")
+    console.print(f"  Symbols:        {stats.get('symbols', '?')}")
+    console.print(f"  Relationships:  {stats.get('relationships', '?')}")
+
+    if stats.get("clusters", 0) > 0:
+        console.print(f"  Clusters:       {stats['clusters']}")
+    if stats.get("flows", 0) > 0:
+        console.print(f"  Flows:          {stats['flows']}")
+    if stats.get("dead_code", 0) > 0:
+        console.print(f"  Dead code:      {stats['dead_code']}")
+    if stats.get("coupled_pairs", 0) > 0:
+        console.print(f"  Coupled pairs:  {stats['coupled_pairs']}")
+
+@app.command(name="list")
+def list_repos() -> None:
+    """List all indexed repositories."""
+    from synaptiq.mcp.tools import handle_list_repos
+
+    result = handle_list_repos()
+    console.print(result)
+
+@app.command()
+def clean(
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation prompt."),
+) -> None:
+    """Delete index for current repository."""
+    repo_path = Path.cwd().resolve()
+    data_dir = repo_path / ".synaptiq"
+
+    if not data_dir.exists():
+        console.print(
+            f"[red]Error:[/red] No index found at {repo_path}. Nothing to clean."
+        )
+        raise typer.Exit(code=1)
+
+    if not force:
+        confirm = typer.confirm(f"Delete index at {data_dir}?")
+        if not confirm:
+            console.print("Aborted.")
+            raise typer.Exit()
+
+    shutil.rmtree(data_dir)
+    console.print(f"[green]Deleted[/green] {data_dir}")
+
+@app.command()
+def query(
+    q: str = typer.Argument(..., help="Search query for the knowledge graph."),
+    limit: int = typer.Option(20, "--limit", "-n", help="Maximum number of results."),
+) -> None:
+    """Search the knowledge graph."""
+    from synaptiq.mcp.tools import handle_query
+
+    storage = _load_storage()
+    result = handle_query(storage, q, limit=limit)
+    console.print(result)
+    storage.close()
+
+@app.command()
+def context(
+    name: str = typer.Argument(..., help="Symbol name to inspect."),
+) -> None:
+    """Show 360-degree view of a symbol."""
+    from synaptiq.mcp.tools import handle_context
+
+    storage = _load_storage()
+    result = handle_context(storage, name)
+    console.print(result)
+    storage.close()
+
+@app.command()
+def impact(
+    target: str = typer.Argument(..., help="Symbol to analyze blast radius for."),
+    depth: int = typer.Option(3, "--depth", "-d", help="Traversal depth."),
+) -> None:
+    """Show blast radius of changing a symbol."""
+    from synaptiq.mcp.tools import handle_impact
+
+    storage = _load_storage()
+    result = handle_impact(storage, target, depth=depth)
+    console.print(result)
+    storage.close()
+
+@app.command(name="dead-code")
+def dead_code() -> None:
+    """List all detected dead code."""
+    from synaptiq.mcp.tools import handle_dead_code
+
+    storage = _load_storage()
+    result = handle_dead_code(storage)
+    console.print(result)
+    storage.close()
+
+@app.command()
+def cypher(
+    query: str = typer.Argument(..., help="Raw Cypher query to execute."),
+) -> None:
+    """Execute raw Cypher against the knowledge graph."""
+    from synaptiq.mcp.tools import handle_cypher
+
+    storage = _load_storage()
+    result = handle_cypher(storage, query)
+    console.print(result)
+    storage.close()
+
+@app.command()
+def setup(
+    claude: bool = typer.Option(False, "--claude", help="Configure MCP for Claude Code."),
+    cursor: bool = typer.Option(False, "--cursor", help="Configure MCP for Cursor."),
+) -> None:
+    """Configure MCP for Claude Code / Cursor."""
+    mcp_config = {
+        "command": "synaptiq",
+        "args": ["serve", "--watch"],
+    }
+
+    if claude or (not claude and not cursor):
+        console.print("[bold]Add to your Claude Code MCP config:[/bold]")
+        console.print(json.dumps({"synaptiq": mcp_config}, indent=2))
+
+    if cursor or (not claude and not cursor):
+        console.print("[bold]Add to your Cursor MCP config:[/bold]")
+        console.print(json.dumps({"synaptiq": mcp_config}, indent=2))
+
+@app.command()
+def watch() -> None:
+    """Watch mode — re-index on file changes."""
+    import asyncio
+
+    from synaptiq.core.ingestion.pipeline import run_pipeline
+    from synaptiq.core.ingestion.watcher import watch_repo
+    from synaptiq.core.storage.kuzu_backend import KuzuBackend
+
+    repo_path = Path.cwd().resolve()
+    data_dir = repo_path / ".synaptiq"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    db_path = data_dir / "kuzu"
+
+    storage = KuzuBackend()
+    storage.initialize(db_path)
+
+    if not (data_dir / "meta.json").exists():
+        console.print("[bold]Running initial index...[/bold]")
+        run_pipeline(repo_path, storage, full=True)
+
+    console.print(f"[bold]Watching[/bold] {repo_path} for changes (Ctrl+C to stop)")
+
+    try:
+        asyncio.run(watch_repo(repo_path, storage))
+    except KeyboardInterrupt:
+        console.print("\n[bold]Watch stopped.[/bold]")
+    finally:
+        storage.close()
+
+@app.command()
+def diff(
+    branch_range: str = typer.Argument(
+        ..., help="Branch range for comparison (e.g. main..feature)."
+    ),
+) -> None:
+    """Structural branch comparison."""
+    from synaptiq.core.diff import diff_branches, format_diff
+
+    repo_path = Path.cwd().resolve()
+    try:
+        result = diff_branches(repo_path, branch_range)
+    except (ValueError, RuntimeError) as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+    console.print(format_diff(result))
+
+@app.command()
+def mcp() -> None:
+    """Start MCP server (stdio transport)."""
+    import asyncio
+
+    from synaptiq.mcp.server import main as mcp_main
+
+    asyncio.run(mcp_main())
+
+@app.command()
+def serve(
+    watch: bool = typer.Option(
+        False, "--watch", "-w", help="Enable file watching with auto-reindex."
+    ),
+) -> None:
+    """Start MCP server, optionally with live file watching."""
+    import asyncio
+    import sys
+
+    from synaptiq.mcp.server import main as mcp_main
+
+    if not watch:
+        asyncio.run(mcp_main())
+        return
+
+    from synaptiq.core.daemon.lock import LockManager
+
+    repo_path = Path.cwd().resolve()
+    data_dir = repo_path / ".synaptiq"
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    lock_mgr = LockManager(data_dir)
+    lock_info = lock_mgr.try_acquire()
+
+    if lock_info is None:
+        # Another instance holds the lock — check if healthy or stale
+        existing = lock_mgr.read_existing()
+        if existing is not None and existing.is_stale():
+            lock_mgr.force_cleanup()
+            lock_info = lock_mgr.try_acquire()
+
+    if lock_info is not None:
+        _serve_primary(repo_path, data_dir, lock_mgr)
+    else:
+        # Re-read in case the lock changed hands during stale cleanup.
+        existing = lock_mgr.read_existing()
+        if existing is None:
+            print("Error: cannot read lock info from primary", file=sys.stderr)
+            raise typer.Exit(code=1)
+        _serve_proxy(existing.socket)
+
+
+def _serve_primary(repo_path: Path, data_dir: Path, lock_mgr) -> None:
+    """Run as primary: DB + watcher + MCP + socket server."""
+    import asyncio
+    import sys
+
+    from synaptiq.core.daemon.socket_server import SocketServer
+    from synaptiq.core.ingestion.pipeline import run_pipeline
+    from synaptiq.core.ingestion.watcher import watch_repo
+    from synaptiq.core.storage.kuzu_backend import KuzuBackend
+    from synaptiq.mcp.server import dispatch_resource, dispatch_tool, set_lock, set_storage
+    from synaptiq.mcp.server import server as mcp_server
+
+    db_path = data_dir / "kuzu"
+    storage = KuzuBackend()
+    storage.initialize(db_path)
+
+    if not (data_dir / "meta.json").exists():
+        print("Running initial index...", file=sys.stderr)
+        run_pipeline(repo_path, storage, full=True)
+
+    lock = asyncio.Lock()
+    set_storage(storage)
+    set_lock(lock)
+
+    def dispatch(method: str, params: dict) -> str:
+        if method == "ping":
+            return "pong"
+        if method == "tool":
+            return dispatch_tool(params.get("name", ""), params.get("arguments", {}), storage)
+        if method == "resource":
+            return dispatch_resource(params.get("uri", ""), storage)
+        return f"Unknown method: {method}"
+
+    socket_server = SocketServer(lock_mgr.socket_path, dispatch, lock=lock)
+
+    async def _run() -> None:
+        from mcp.server.stdio import stdio_server
+        stop = asyncio.Event()
+        await socket_server.start()
+        try:
+            async with stdio_server() as (read, write):
+                async def _mcp_then_stop():
+                    await mcp_server.run(read, write, mcp_server.create_initialization_options())
+                    stop.set()
+                await asyncio.gather(
+                    _mcp_then_stop(),
+                    watch_repo(repo_path, storage, stop_event=stop, lock=lock),
+                )
+        finally:
+            await socket_server.stop()
+
+    try:
+        asyncio.run(_run())
+    except KeyboardInterrupt:
+        pass
+    finally:
+        storage.close()
+        lock_mgr.release()
+
+
+def _serve_proxy(socket_path: str) -> None:
+    """Run as proxy: MCP over stdio, forwarding to primary via socket."""
+    import asyncio
+
+    from synaptiq.core.daemon.socket_client import SocketClient
+    from synaptiq.mcp.server import set_proxy_client
+
+    client = SocketClient(Path(socket_path))
+
+    async def _run() -> None:
+        import sys
+
+        from mcp.server.stdio import stdio_server
+
+        from synaptiq.mcp.server import server as mcp_server
+
+        # Retry connection — the primary may still be starting its socket server.
+        for attempt in range(5):
+            try:
+                await client.connect()
+                break
+            except ConnectionError:
+                if attempt == 4:
+                    print("Error: could not connect to primary socket", file=sys.stderr)
+                    raise
+                await asyncio.sleep(0.2 * (attempt + 1))
+
+        set_proxy_client(client)
+        try:
+            async with stdio_server() as (read, write):
+                await mcp_server.run(read, write, mcp_server.create_initialization_options())
+        finally:
+            await client.close()
+
+    try:
+        asyncio.run(_run())
+    except KeyboardInterrupt:
+        pass

synaptiq/config/__init__.py

@@ -0,0 +1,13 @@
+"""Synaptiq configuration — ignore patterns and language detection."""
+
+from synaptiq.config.ignore import DEFAULT_IGNORE_PATTERNS, load_gitignore, should_ignore
+from synaptiq.config.languages import SUPPORTED_EXTENSIONS, get_language, is_supported
+
+__all__ = [
+    "DEFAULT_IGNORE_PATTERNS",
+    "SUPPORTED_EXTENSIONS",
+    "get_language",
+    "is_supported",
+    "load_gitignore",
+    "should_ignore",
+]

synaptiq/config/ignore.py

@@ -0,0 +1,135 @@
+"""Ignore-pattern handling for Synaptiq's file discovery."""
+
+from __future__ import annotations
+
+import fnmatch
+from pathlib import Path
+
+DEFAULT_IGNORE_PATTERNS: frozenset[str] = frozenset(
+    {
+        # Directories
+        "node_modules",
+        "__pycache__",
+        ".git",
+        ".synaptiq",
+        ".venv",
+        "venv",
+        ".env",
+        "dist",
+        "build",
+        ".idea",
+        ".vscode",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+        ".tox",
+        "egg-info",
+        ".eggs",
+        "coverage",
+        "htmlcov",
+        # Files (exact names)
+        ".DS_Store",
+        ".coverage",
+        "package-lock.json",
+        "yarn.lock",
+        "uv.lock",
+        "poetry.lock",
+        # File globs
+        "*.pyc",
+        "*.pyo",
+        "*.so",
+        "*.dylib",
+        "*.min.js",
+        "*.bundle.js",
+        "*.map",
+    }
+)
+
+# Separate glob patterns (contain wildcards) from literal names at module load
+# so we only compute this once.
+_GLOB_PATTERNS: frozenset[str] = frozenset(
+    p for p in DEFAULT_IGNORE_PATTERNS if "*" in p or "?" in p
+)
+_LITERAL_PATTERNS: frozenset[str] = DEFAULT_IGNORE_PATTERNS - _GLOB_PATTERNS
+
+def _matches_default_patterns(path: Path) -> bool:
+    """Check whether *path* (relative) matches any default ignore pattern."""
+    for part in path.parts:
+        if part in _LITERAL_PATTERNS:
+            return True
+        # Also check globs against every component (e.g. *.pyc — unlikely but consistent)
+        for pattern in _GLOB_PATTERNS:
+            if fnmatch.fnmatch(part, pattern):
+                return True
+    return False
+
+_pathspec_cache: dict[tuple[str, ...], object] = {}
+
+def _matches_gitignore(path: Path, gitignore_patterns: list[str]) -> bool:
+    """Check *path* against a list of gitignore-style patterns.
+
+    Uses ``pathspec`` when available for full gitignore semantics; falls back to
+    fnmatch per-pattern otherwise.  The compiled pathspec is cached by the
+    pattern content so it is only built once per unique pattern set.
+    """
+    if not gitignore_patterns:
+        return False
+
+    try:
+        import pathspec
+
+        cache_key = tuple(gitignore_patterns)
+        spec = _pathspec_cache.get(cache_key)
+        if spec is None:
+            spec = pathspec.PathSpec.from_lines("gitignore", gitignore_patterns)
+            _pathspec_cache[cache_key] = spec
+        return spec.match_file(str(path))  # type: ignore[union-attr]
+    except ImportError:  # pragma: no cover — pathspec is a declared dependency
+        path_str = str(path)
+        for pattern in gitignore_patterns:
+            if fnmatch.fnmatch(path_str, pattern):
+                return True
+            if fnmatch.fnmatch(path.name, pattern):
+                return True
+        return False
+
+def should_ignore(
+    path: str | Path,
+    gitignore_patterns: list[str] | None = None,
+) -> bool:
+    """Return ``True`` if *path* should be ignored during file discovery.
+
+    Parameters
+    ----------
+    path:
+        A relative file path (e.g. ``src/main.py`` or ``node_modules/pkg/index.js``).
+    gitignore_patterns:
+        Optional list of gitignore-style patterns loaded via :func:`load_gitignore`.
+    """
+    p = Path(path)
+
+    if _matches_default_patterns(p):
+        return True
+
+    if gitignore_patterns and _matches_gitignore(p, gitignore_patterns):
+        return True
+
+    return False
+
+def load_gitignore(repo_path: Path) -> list[str]:
+    """Read ``.gitignore`` from *repo_path* and return a list of patterns.
+
+    Blank lines and comments (lines starting with ``#``) are stripped.
+    Returns an empty list when the file does not exist.
+    """
+    gitignore = repo_path / ".gitignore"
+    if not gitignore.is_file():
+        return []
+
+    lines: list[str] = []
+    text = gitignore.read_text(encoding="utf-8")
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if line and not line.startswith("#"):
+            lines.append(line)
+    return lines

synaptiq/config/languages.py

@@ -0,0 +1,27 @@
+"""Language detection based on file extensions."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+SUPPORTED_EXTENSIONS: dict[str, str] = {
+    ".py": "python",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+}
+
+def get_language(file_path: str | Path) -> str | None:
+    """Return the language name for *file_path* based on its extension.
+
+    Returns ``None`` when the extension is not in :data:`SUPPORTED_EXTENSIONS`.
+    """
+    suffix = Path(file_path).suffix
+    return SUPPORTED_EXTENSIONS.get(suffix)
+
+def is_supported(file_path: str | Path) -> bool:
+    """Return ``True`` if *file_path* has a supported extension."""
+    return Path(file_path).suffix in SUPPORTED_EXTENSIONS

synaptiq/core/__init__.py

@@ -0,0 +1 @@
+

synaptiq/core/daemon/__init__.py

@@ -0,0 +1 @@
+"""Daemon coordination for multi-instance synaptiq serve --watch."""