sari 0.0.1__py3-none-any.whl

app/workspace.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+"""
+Workspace management for Local Search MCP Server.
+Handles workspace detection and global path resolution.
+"""
+import os
+import hashlib
+from pathlib import Path
+from typing import Optional
+
+
+class WorkspaceManager:
+    """Manages workspace detection and global paths."""
+
+    @staticmethod
+    def _normalize_path(path: str, follow_symlinks: bool) -> str:
+        expanded = os.path.expanduser(path)
+        if follow_symlinks:
+            normalized = os.path.realpath(expanded)
+        else:
+            normalized = os.path.abspath(expanded)
+        if os.name == "nt":
+            normalized = normalized.lower()
+        return normalized.rstrip(os.sep)
+
+    @staticmethod
+    def root_id(path: str) -> str:
+        """Stable root id derived from normalized path."""
+        follow_symlinks = (os.environ.get("DECKARD_FOLLOW_SYMLINKS", "0").strip().lower() in ("1", "true", "yes", "on"))
+        norm = WorkspaceManager._normalize_path(path, follow_symlinks=follow_symlinks)
+        digest = hashlib.sha1(norm.encode("utf-8")).hexdigest()[:8]
+        return f"root-{digest}"
+
+    @staticmethod
+    def resolve_workspace_roots(
+        root_uri: Optional[str] = None,
+        roots_json: Optional[str] = None,
+        roots_env: Optional[dict] = None,
+        config_roots: Optional[list] = None
+    ) -> list[str]:
+        """
+        Resolve multiple workspace roots with priority, normalization, and deduplication.
+        
+        Priority (Union & Merge):
+        1. config.roots
+        2. DECKARD_ROOTS_JSON
+        3. DECKARD_ROOT_1..N
+        4. DECKARD_WORKSPACE_ROOT (legacy)
+        5. LOCAL_SEARCH_WORKSPACE_ROOT (legacy)
+        6. root_uri (MCP initialize param, ephemeral)
+        7. Fallback to cwd (only if no candidates)
+        
+        Returns:
+            List of absolute, normalized paths.
+        """
+        candidates: list[tuple[str, str]] = []
+        env_vars = roots_env if roots_env is not None else os.environ
+        follow_symlinks = (env_vars.get("DECKARD_FOLLOW_SYMLINKS", "0").strip().lower() in ("1", "true", "yes", "on"))
+        keep_nested = (env_vars.get("DECKARD_KEEP_NESTED_ROOTS", "0").strip().lower() in ("1", "true", "yes", "on"))
+
+        # 1. config.roots
+        if config_roots:
+            for x in config_roots:
+                if x:
+                    candidates.append((str(x), "config"))
+
+        # 2. DECKARD_ROOTS_JSON
+        import json
+        json_str = roots_json or env_vars.get("DECKARD_ROOTS_JSON", "")
+        if json_str:
+            try:
+                loaded = json.loads(json_str)
+                if isinstance(loaded, list):
+                    for x in loaded:
+                        if x:
+                            candidates.append((str(x), "env"))
+            except Exception:
+                pass
+                
+        # 3. DECKARD_ROOT_1..N
+        for k, v in env_vars.items():
+            if k.startswith("DECKARD_ROOT_") and k[13:].isdigit():
+                if v and v.strip():
+                    candidates.append((v.strip(), "env"))
+                    
+        # 4. Legacy DECKARD_WORKSPACE_ROOT (Higher priority than LOCAL_SEARCH)
+        legacy_val = (env_vars.get("DECKARD_WORKSPACE_ROOT") or "").strip()
+        if legacy_val:
+            if legacy_val == "${cwd}":
+                candidates.append((os.getcwd(), "env"))
+            else:
+                candidates.append((legacy_val, "env"))
+
+        # 5. Legacy LOCAL_SEARCH_WORKSPACE_ROOT
+        ls_val = (env_vars.get("LOCAL_SEARCH_WORKSPACE_ROOT") or "").strip()
+        if ls_val:
+            if ls_val == "${cwd}":
+                candidates.append((os.getcwd(), "env"))
+            else:
+                candidates.append((ls_val, "env"))
+        
+        # 6. root_uri (ephemeral)
+        if root_uri:
+            uri_path = root_uri[7:] if root_uri.startswith("file://") else root_uri
+            try:
+                if uri_path:
+                    candidate = os.path.expanduser(uri_path)
+                    if os.path.exists(candidate):
+                        candidates.append((candidate, "root_uri"))
+            except Exception:
+                pass
+        
+        # 7. Fallback to cwd
+        if not candidates:
+            candidates.append((os.getcwd(), "fallback"))
+            
+        # Normalization
+        resolved_paths: list[tuple[str, str]] = []
+        seen = set()
+        for p, src in candidates:
+            try:
+                abs_path = WorkspaceManager._normalize_path(p, follow_symlinks=follow_symlinks)
+                if abs_path not in seen:
+                    resolved_paths.append((abs_path, src))
+                    seen.add(abs_path)
+            except Exception:
+                continue
+                
+        # Inclusion check while preserving priority order (first seen wins)
+        final_roots: list[str] = []
+        final_meta: list[tuple[str, str]] = []
+        if keep_nested:
+            for p, src in resolved_paths:
+                final_roots.append(p)
+                final_meta.append((p, src))
+        else:
+            for p, src in resolved_paths:
+                p_path = Path(p)
+                is_covered = False
+                for existing, ex_src in final_meta:
+                    try:
+                        existing_path = Path(existing)
+                        # If root_uri is a child of config/env, drop root_uri
+                        if src == "root_uri" and ex_src in {"config", "env"}:
+                            if p_path == existing_path or existing_path in p_path.parents or p.startswith(existing + os.sep):
+                                is_covered = True
+                                break
+                        # If root_uri is parent of config/env, keep both (skip collapse)
+                        if ex_src == "root_uri" and src in {"config", "env"}:
+                            if p_path == existing_path or p.startswith(existing + os.sep) or existing_path in p_path.parents:
+                                is_covered = False
+                                continue
+                        # Default: collapse nested roots (parent keeps, child removed)
+                        if p_path == existing_path or existing_path in p_path.parents or p.startswith(existing + os.sep):
+                            is_covered = True
+                            break
+                    except Exception:
+                        continue
+                if not is_covered:
+                    final_meta.append((p, src))
+                    final_roots.append(p)
+
+        return final_roots
+
+    @staticmethod
+    def resolve_workspace_root(root_uri: Optional[str] = None) -> str:
+        """
+        Unified resolver for workspace root directory.
+        Legacy wrapper around resolve_workspace_roots.
+        Returns the first resolved root.
+        """
+        roots = WorkspaceManager.resolve_workspace_roots(root_uri=root_uri)
+        return roots[0] if roots else str(Path.cwd())
+
+    @staticmethod
+    def is_path_allowed(path: str, roots: list[str]) -> bool:
+        """Check if path is within any of the roots."""
+        try:
+            follow_symlinks = (os.environ.get("DECKARD_FOLLOW_SYMLINKS", "0").strip().lower() in ("1", "true", "yes", "on"))
+            p = Path(WorkspaceManager._normalize_path(path, follow_symlinks=follow_symlinks))
+            for r in roots:
+                root_path = Path(WorkspaceManager._normalize_path(r, follow_symlinks=follow_symlinks))
+                if p == root_path or root_path in p.parents:
+                    return True
+            return False
+        except Exception:
+            return False
+
+    @staticmethod
+    def detect_workspace(root_uri: Optional[str] = None) -> str:
+        """Legacy alias for resolve_workspace_root."""
+        return WorkspaceManager.resolve_workspace_root(root_uri)
+
+    @staticmethod
+    def resolve_config_path(workspace_root: str) -> str:
+        """
+        Resolve config path with unified priority.
+        
+        Priority:
+        1. DECKARD_CONFIG environment variable (SSOT)
+        2. Default SSOT path (~/.config/sari/config.json or %APPDATA%/sari/config.json)
+        """
+        val = (os.environ.get("DECKARD_CONFIG") or "").strip()
+        if val:
+            p = Path(os.path.expanduser(val))
+            if p.exists():
+                return str(p.resolve())
+
+        if os.name == "nt":
+            ssot = Path(os.environ.get("APPDATA", os.path.expanduser("~\\AppData\\Roaming"))) / "sari" / "config.json"
+        else:
+            ssot = Path.home() / ".config" / "sari" / "config.json"
+
+        if ssot.exists():
+            return str(ssot.resolve())
+
+        # Legacy migration (one-time copy + backup)
+        legacy_candidates = [
+            Path(workspace_root) / ".codex" / "tools" / "deckard" / "config" / "config.json",
+            Path.home() / ".deckard" / "config.json",
+        ]
+        for legacy in legacy_candidates:
+            if legacy.exists():
+                try:
+                    ssot.parent.mkdir(parents=True, exist_ok=True)
+                    ssot.write_text(legacy.read_text(encoding="utf-8"), encoding="utf-8")
+                    bak = legacy.with_suffix(legacy.suffix + ".bak")
+                    try:
+                        legacy.rename(bak)
+                    except Exception:
+                        marker = legacy.parent / ".migrated"
+                        marker.write_text(f"migrated to {ssot}", encoding="utf-8")
+                    print(f"[sari] migrated legacy config from {legacy} to {ssot}")
+                except Exception:
+                    pass
+                break
+
+        return str(ssot.resolve())
+    
+    @staticmethod
+    def get_global_data_dir() -> Path:
+        """Get global data directory: ~/.local/share/sari/ (or AppData/Local on Win)"""
+        if os.name == "nt":
+            return Path(os.environ.get("LOCALAPPDATA", os.path.expanduser("~\\AppData\\Local"))) / "sari"
+        return Path.home() / ".local" / "share" / "sari"
+    
+    @staticmethod
+    def get_global_db_path() -> Path:
+        """Get global DB path: ~/.local/share/sari/index.db (Opt-in only)"""
+        return WorkspaceManager.get_global_data_dir() / "index.db"
+
+    @staticmethod
+    def get_local_db_path(workspace_root: str) -> Path:
+        """Get workspace-local DB path: .codex/tools/sari/data/index.db"""
+        return Path(workspace_root) / ".codex" / "tools" / "sari" / "data" / "index.db"
+    
+    @staticmethod
+    def get_global_log_dir() -> Path:
+        """Get global log directory, with env override."""
+        for env_key in ["DECKARD_LOG_DIR", "LOCAL_SEARCH_LOG_DIR"]:
+            val = (os.environ.get(env_key) or "").strip()
+            if val:
+                return Path(os.path.expanduser(val)).resolve()
+        return WorkspaceManager.get_global_data_dir() / "logs"
+
+    @staticmethod
+    def roots_hash(root_ids: list[str]) -> str:
+        joined = "|".join(sorted(root_ids))
+        digest = hashlib.sha1(joined.encode("utf-8")).hexdigest()[:12]
+        return digest
+
+    @staticmethod
+    def get_engine_base_dir() -> Path:
+        return WorkspaceManager.get_global_data_dir() / "engine"
+
+    @staticmethod
+    def get_engine_venv_dir() -> Path:
+        return WorkspaceManager.get_engine_base_dir() / ".venv"
+
+    @staticmethod
+    def get_engine_cache_dir() -> Path:
+        return Path(os.path.expanduser("~/.cache")) / "sari" / "engine"
+
+    @staticmethod
+    def get_engine_index_dir(roots_hash: str) -> Path:
+        return WorkspaceManager.get_global_data_dir() / "index" / roots_hash

deckard/__init__.py

@@ -0,0 +1,3 @@
+from .version import __version__
+
+__all__ = ["main", "__version__"]

deckard/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

deckard/main.py

@@ -0,0 +1,345 @@
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import List
+
+from app.workspace import WorkspaceManager
+from app.config import Config
+from app.db import LocalSearchDB
+from app.engine_registry import get_default_engine
+from mcp.tools._util import pack_error, ErrorCode
+
+
+def _print_transport_error(fmt: str) -> int:
+    msg = "MCP-over-HTTP transport is not supported."
+    if fmt == "json":
+        payload = {"error": {"code": ErrorCode.ERR_MCP_HTTP_UNSUPPORTED.value, "message": msg}}
+        print(json.dumps(payload, ensure_ascii=False))
+    else:
+        print(pack_error("server", ErrorCode.ERR_MCP_HTTP_UNSUPPORTED, msg))
+    return 1
+
+
+def _write_toml_block(cfg_path: Path, command: str, args: List[str], env: dict) -> None:
+    cfg_path.parent.mkdir(parents=True, exist_ok=True)
+    lines = cfg_path.read_text(encoding="utf-8").splitlines() if cfg_path.exists() else []
+    new_lines = []
+    in_sari = False
+    for line in lines:
+        if line.strip() == "[mcp_servers.sari]":
+            in_sari = True
+            continue
+        if in_sari and line.startswith("[") and line.strip() != "[mcp_servers.sari]":
+            in_sari = False
+            new_lines.append(line)
+            continue
+        if not in_sari:
+            new_lines.append(line)
+    env_kv = ", ".join([f'{k} = "{v}"' for k, v in env.items()])
+    block = [
+        "[mcp_servers.sari]",
+        f'command = "{command}"',
+        f"args = {json.dumps(args)}",
+        f"env = {{ {env_kv} }}",
+        "startup_timeout_sec = 60",
+    ]
+    new_lines = block + new_lines
+    cfg_path.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
+
+
+def _write_json_settings(cfg_path: Path, command: str, args: List[str], env: dict) -> None:
+    cfg_path.parent.mkdir(parents=True, exist_ok=True)
+    data = {}
+    if cfg_path.exists():
+        try:
+            data = json.loads(cfg_path.read_text(encoding="utf-8"))
+        except Exception:
+            data = {}
+    mcp_servers = data.get("mcpServers") or {}
+    mcp_servers["sari"] = {"command": command, "args": args, "env": env}
+    data["mcpServers"] = mcp_servers
+    cfg_path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def _cmd_install(host: str, do_print: bool) -> int:
+    ssot = WorkspaceManager.resolve_config_path(str(Path.cwd()))
+    env = {
+        "DECKARD_CONFIG": ssot,
+    }
+    args = ["--transport", "stdio", "--format", "pack"]
+    command = "sari"
+
+    if do_print:
+        payload = {
+            "command": command,
+            "args": args,
+            "env": env,
+        }
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+        return 0
+
+    if host in {"codex", "gemini"}:
+        cfg_path = Path.cwd() / f".{host}" / "config.toml"
+        _write_toml_block(cfg_path, command, args, env)
+        print(f"[sari] Updated {cfg_path}")
+        return 0
+    if host in {"claude"}:
+        if os.name == "nt":
+            cfg_path = Path(os.environ.get("APPDATA", os.path.expanduser("~\\AppData\\Roaming"))) / "Claude" / "claude_desktop_config.json"
+        else:
+            cfg_path = Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"
+        _write_json_settings(cfg_path, command, args, env)
+        print(f"[sari] Updated {cfg_path}")
+        return 0
+    if host in {"cursor"}:
+        cfg_path = Path.home() / ".cursor" / "mcp.json"
+        _write_json_settings(cfg_path, command, args, env)
+        print(f"[sari] Updated {cfg_path}")
+        return 0
+
+    print(f"[sari] Unsupported host: {host}", file=sys.stderr)
+    return 2
+
+
+def _cmd_config_show() -> int:
+    cfg_path = WorkspaceManager.resolve_config_path(str(Path.cwd()))
+    if not Path(cfg_path).exists():
+        print("{}")
+        return 0
+    print(Path(cfg_path).read_text(encoding="utf-8"))
+    return 0
+
+
+def _cmd_roots_list() -> int:
+    cfg_path = WorkspaceManager.resolve_config_path(str(Path.cwd()))
+    if not Path(cfg_path).exists():
+        print("[]")
+        return 0
+    data = json.loads(Path(cfg_path).read_text(encoding="utf-8"))
+    roots = data.get("roots") or data.get("workspace_roots") or []
+    print(json.dumps(roots, ensure_ascii=False, indent=2))
+    return 0
+
+
+def _cmd_roots_add(path: str) -> int:
+    cfg_path = WorkspaceManager.resolve_config_path(str(Path.cwd()))
+    data = {}
+    if Path(cfg_path).exists():
+        try:
+            data = json.loads(Path(cfg_path).read_text(encoding="utf-8"))
+        except Exception:
+            data = {}
+    roots = data.get("roots") or data.get("workspace_roots") or []
+    roots = [r for r in roots if r]
+    roots.append(path)
+    final = WorkspaceManager.resolve_workspace_roots(root_uri=None, roots_env={}, config_roots=roots)
+    data["roots"] = final
+    Path(cfg_path).parent.mkdir(parents=True, exist_ok=True)
+    Path(cfg_path).write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(final, ensure_ascii=False, indent=2))
+    return 0
+
+
+def _cmd_roots_remove(path: str) -> int:
+    cfg_path = WorkspaceManager.resolve_config_path(str(Path.cwd()))
+    if not Path(cfg_path).exists():
+        print("[]")
+        return 0
+    data = json.loads(Path(cfg_path).read_text(encoding="utf-8"))
+    roots = data.get("roots") or data.get("workspace_roots") or []
+    roots = [r for r in roots if r and r != path]
+    data["roots"] = roots
+    Path(cfg_path).write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(roots, ensure_ascii=False, indent=2))
+    return 0
+
+
+def _cmd_index() -> int:
+    try:
+        from mcp.cli import _request_http
+        _request_http("/rescan", {})
+        print(json.dumps({"requested": True}))
+        return 0
+    except Exception as e:
+        print(json.dumps({"requested": False, "error": str(e)}))
+        return 1
+
+
+def _cmd_status() -> int:
+    try:
+        from mcp.cli import _request_http
+        data = _request_http("/status", {})
+        print(json.dumps(data, ensure_ascii=False, indent=2))
+        return 0
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        return 1
+
+
+def _load_engine_context():
+    workspace_root = WorkspaceManager.resolve_workspace_root()
+    cfg_path = WorkspaceManager.resolve_config_path(str(Path.cwd()))
+    cfg = Config.load(cfg_path, workspace_root_override=workspace_root)
+    db = LocalSearchDB(cfg.db_path)
+    db.set_engine(get_default_engine(db, cfg, cfg.workspace_roots))
+    return cfg, db
+
+
+def _cmd_engine_status() -> int:
+    try:
+        _cfg, db = _load_engine_context()
+        if hasattr(db.engine, "status"):
+            st = db.engine.status()
+            print(json.dumps(st.__dict__, ensure_ascii=False, indent=2))
+            return 0
+        print(json.dumps({"error": "engine status unsupported"}, ensure_ascii=False, indent=2))
+        return 1
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        return 1
+
+
+def _cmd_engine_install() -> int:
+    try:
+        _cfg, db = _load_engine_context()
+        if hasattr(db.engine, "install"):
+            db.engine.install()
+            print(json.dumps({"ok": True}))
+            return 0
+        print(json.dumps({"error": "engine install unsupported"}))
+        return 1
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        return 1
+
+
+def _cmd_engine_rebuild() -> int:
+    try:
+        _cfg, db = _load_engine_context()
+        if hasattr(db.engine, "rebuild"):
+            db.engine.rebuild()
+            print(json.dumps({"ok": True}))
+            return 0
+        print(json.dumps({"error": "engine rebuild unsupported"}))
+        return 1
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        return 1
+
+
+def _cmd_engine_verify() -> int:
+    try:
+        _cfg, db = _load_engine_context()
+        if hasattr(db.engine, "status"):
+            st = db.engine.status()
+            if st.engine_ready:
+                print(json.dumps({"ok": True}))
+                return 0
+            print(json.dumps({"ok": False, "reason": st.reason, "hint": st.hint}))
+            return 2
+        print(json.dumps({"error": "engine status unsupported"}))
+        return 1
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        return 1
+
+
+def _cmd_doctor() -> int:
+    try:
+        from doctor import run_doctor
+        run_doctor()
+        return 0
+    except Exception as e:
+        print(str(e), file=sys.stderr)
+        return 1
+
+
+def run_cmd(argv: List[str]) -> int:
+    if not argv:
+        print("missing subcommand", file=sys.stderr)
+        return 2
+    if argv[0] == "doctor":
+        return _cmd_doctor()
+    if argv[0] == "status":
+        return _cmd_status()
+    if argv[0] == "config" and len(argv) > 1 and argv[1] == "show":
+        return _cmd_config_show()
+    if argv[0] == "roots":
+        if len(argv) < 2:
+            print("roots add|remove|list", file=sys.stderr)
+            return 2
+        if argv[1] == "list":
+            return _cmd_roots_list()
+        if argv[1] == "add" and len(argv) > 2:
+            return _cmd_roots_add(argv[2])
+        if argv[1] == "remove" and len(argv) > 2:
+            return _cmd_roots_remove(argv[2])
+    if argv[0] == "index":
+        return _cmd_index()
+    if argv[0] == "install":
+        parser = argparse.ArgumentParser(prog="sari --cmd install")
+        parser.add_argument("--host", required=True, choices=["codex", "gemini", "claude", "cursor"])
+        parser.add_argument("--print", action="store_true")
+        ns = parser.parse_args(argv[1:])
+        return _cmd_install(ns.host, ns.print)
+    if argv[0] == "engine":
+        if len(argv) < 2:
+            print("engine status|install|rebuild|verify", file=sys.stderr)
+            return 2
+        action = argv[1]
+        if action == "status":
+            return _cmd_engine_status()
+        if action == "install":
+            return _cmd_engine_install()
+        if action == "rebuild":
+            return _cmd_engine_rebuild()
+        if action == "verify":
+            return _cmd_engine_verify()
+    print(f"Unknown subcommand: {argv[0]}", file=sys.stderr)
+    return 2
+
+
+def main(argv: List[str] = None) -> int:
+    argv = list(argv or sys.argv[1:])
+    if argv and argv[0] in {"daemon", "proxy", "status", "search", "init"}:
+        from mcp.cli import main as legacy_main
+        sys.argv = ["sari"] + argv
+        return legacy_main()
+    if "--cmd" in argv:
+        idx = argv.index("--cmd")
+        cmd_args = argv[idx + 1 :]
+        return run_cmd(cmd_args)
+
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--transport", default="stdio", choices=["stdio", "http"])
+    parser.add_argument("--format", default="pack", choices=["pack", "json"])
+    parser.add_argument("--http-api", action="store_true")
+    parser.add_argument("--http-api-port")
+    parser.add_argument("--version", action="store_true")
+    parser.add_argument("--help", action="store_true")
+    ns, _ = parser.parse_known_args(argv)
+
+    if ns.help:
+        print("sari [--transport stdio|http] [--format pack|json] [--http-api] [--cmd <subcommand>]")
+        return 0
+    if ns.version:
+        from mcp.server import LocalSearchMCPServer
+        print(LocalSearchMCPServer.SERVER_VERSION)
+        return 0
+
+    os.environ["DECKARD_FORMAT"] = ns.format
+
+    if ns.http_api:
+        if ns.http_api_port:
+            os.environ["DECKARD_HTTP_API_PORT"] = str(ns.http_api_port)
+        from app.main import main as http_main
+        return http_main()
+
+    if ns.transport == "http":
+        return _print_transport_error(ns.format)
+
+    from mcp.server import main as mcp_main
+    mcp_main()
+    return 0

deckard/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

mcp/__init__.py

@@ -0,0 +1 @@
+# MCP Server for Local Search

mcp/__main__.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""
+Entry point for `python -m mcp` execution.
+
+Routes to either:
+- CLI mode (sari daemon/proxy commands)
+- Legacy server mode (for backward compatibility)
+"""
+import sys
+
+if __name__ == "__main__":
+    # Check if running as CLI
+    if len(sys.argv) > 1 and sys.argv[1] in ("daemon", "proxy"):
+        from .cli import main
+        sys.exit(main())
+    else:
+        # Legacy: Run as stdio MCP server
+        from .server import main
+        main()