superlocalmemory 3.6.23 → 3.7.1

package/src/superlocalmemory/cli/service_installer.py

@@ -19,11 +19,13 @@ from __future__ import annotations
 
 import logging
 import os
-import shutil
+import plistlib
 import subprocess
 import sys
 from pathlib import Path
 
+from superlocalmemory.infra.data_root import canonical_data_root, state_path
+
 logger = logging.getLogger(__name__)
 
 _SERVICE_NAME = "com.qualixar.superlocalmemory"
@@ -36,13 +38,13 @@ def get_python_path() -> str:
 
 
 def get_log_path() -> Path:
-    log_dir = Path.home() / ".superlocalmemory" / "logs"
+    log_dir = state_path("logs")
     log_dir.mkdir(parents=True, exist_ok=True)
     return log_dir / "daemon.log"
 
 
 def get_error_log_path() -> Path:
-    log_dir = Path.home() / ".superlocalmemory" / "logs"
+    log_dir = state_path("logs")
     log_dir.mkdir(parents=True, exist_ok=True)
     return log_dir / "daemon-error.log"
 
@@ -57,44 +59,29 @@ def _macos_plist_content() -> str:
     python = get_python_path()
     log = get_log_path()
     err_log = get_error_log_path()
-
-    return f"""<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
-  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>{_SERVICE_NAME}</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>{python}</string>
-        <string>-m</string>
-        <string>superlocalmemory.server.unified_daemon</string>
-        <string>--start</string>
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <dict>
-        <key>SuccessfulExit</key>
-        <false/>
-    </dict>
-    <key>ThrottleInterval</key>
-    <integer>30</integer>
-    <key>StandardOutPath</key>
-    <string>{log}</string>
-    <key>StandardErrorPath</key>
-    <string>{err_log}</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>/usr/local/bin:/usr/bin:/bin:{Path(python).parent}</string>
-        <key>HOME</key>
-        <string>{Path.home()}</string>
-    </dict>
-</dict>
-</plist>
-"""
+    port = str(_configured_daemon_port())
+    payload = {
+        "Label": _SERVICE_NAME,
+        "ProgramArguments": [
+            python,
+            "-m",
+            "superlocalmemory.server.unified_daemon",
+            "--start",
+            f"--port={port}",
+        ],
+        "RunAtLoad": True,
+        "KeepAlive": {"SuccessfulExit": False},
+        "ThrottleInterval": 30,
+        "StandardOutPath": str(log),
+        "StandardErrorPath": str(err_log),
+        "EnvironmentVariables": {
+            "PATH": f"/usr/local/bin:/usr/bin:/bin:{Path(python).parent}",
+            "HOME": str(Path.home()),
+            "SLM_DATA_DIR": str(canonical_data_root()),
+            "SLM_DAEMON_PORT": port,
+        },
+    }
+    return plistlib.dumps(payload, fmt=plistlib.FMT_XML, sort_keys=False).decode()
 
 
 def install_macos() -> bool:
@@ -163,6 +150,8 @@ def _linux_service_path() -> Path:
 def _linux_service_content() -> str:
     python = get_python_path()
     log = get_log_path()
+    root = canonical_data_root()
+    port = _configured_daemon_port()
 
     return f"""[Unit]
 Description={_DISPLAY_NAME}
@@ -170,13 +159,15 @@ After=network.target
 
 [Service]
 Type=simple
-ExecStart={python} -m superlocalmemory.server.unified_daemon --start
+ExecStart={python} -m superlocalmemory.server.unified_daemon --start --port={port}
 Restart=on-failure
 RestartSec=30
 StandardOutput=append:{log}
 StandardError=append:{get_error_log_path()}
 Environment=HOME={Path.home()}
 Environment=PATH=/usr/local/bin:/usr/bin:/bin:{Path(python).parent}
+Environment="SLM_DATA_DIR={root}"
+Environment="SLM_DAEMON_PORT={port}"
 
 [Install]
 WantedBy=default.target
@@ -247,18 +238,32 @@ def status_linux() -> dict:
 _WINDOWS_TASK_NAME = "SuperLocalMemory"
 
 
-def install_windows() -> bool:
-    python = get_python_path()
-    log = get_log_path()
+def _configured_daemon_port() -> int:
+    try:
+        port = int(os.environ.get("SLM_DAEMON_PORT", "") or 8765)
+    except ValueError:
+        port = 8765
+    return port if 1 <= port <= 65535 else 8765
+
+
+def _windows_vbs_content() -> str:
+    python = str(get_python_path()).replace('"', '""')
+    root = str(canonical_data_root()).replace('"', '""')
+    port = str(_configured_daemon_port())
+    return (
+        'Set WshShell = CreateObject("WScript.Shell")\n'
+        f'WshShell.Environment("Process")("SLM_DATA_DIR") = "{root}"\n'
+        f'WshShell.Environment("Process")("SLM_DAEMON_PORT") = "{port}"\n'
+        f'WshShell.Run """{python}"" -m superlocalmemory.server.unified_daemon '
+        f'--start --port={port}", 0, False\n'
+    )
 
+
+def install_windows() -> bool:
     # Create a VBS wrapper to run Python without console window
-    vbs_path = Path.home() / ".superlocalmemory" / "start-daemon.vbs"
+    vbs_path = state_path("start-daemon.vbs")
     vbs_path.parent.mkdir(parents=True, exist_ok=True)
-    vbs_content = (
-        f'Set WshShell = CreateObject("WScript.Shell")\n'
-        f'WshShell.Run """{python}"" -m superlocalmemory.server.unified_daemon --start", 0, False\n'
-    )
-    vbs_path.write_text(vbs_content)
+    vbs_path.write_text(_windows_vbs_content())
 
     # Use schtasks to create a logon trigger task
     try:
@@ -303,7 +308,7 @@ def uninstall_windows() -> bool:
     except Exception:
         pass
 
-    vbs_path = Path.home() / ".superlocalmemory" / "start-daemon.vbs"
+    vbs_path = state_path("start-daemon.vbs")
     if vbs_path.exists():
         vbs_path.unlink()
 

package/src/superlocalmemory/cli/setup_wizard.py

@@ -31,15 +31,9 @@ from pathlib import Path
 # WP-07: resolve via slm_home() so all 3 env aliases are honoured.
 # Fallback keeps stdlib-only path if the import fails during early bootstrap.
 def _resolve_slm_home() -> Path:
-    try:
-        from superlocalmemory.cli._lazy_init import slm_home
-        return slm_home()
-    except Exception:
-        return Path(os.environ.get("SL_MEMORY_PATH", "") or Path.home() / ".superlocalmemory")
-
+    from superlocalmemory.infra.data_root import canonical_data_root
 
-_SLM_HOME = _resolve_slm_home()
-_SETUP_MARKER = _SLM_HOME / ".setup-complete"
+    return canonical_data_root()
 _EMBED_MODEL = "nomic-ai/nomic-embed-text-v1.5"
 _RERANKER_MODEL = "cross-encoder/ms-marco-MiniLM-L-12-v2"
 # v3.6.10: compulsory LLMLingua-2 prose compression model (~560MB, aggressive mode).
@@ -61,7 +55,7 @@ def is_interactive() -> bool:
 
 def is_setup_complete() -> bool:
     """True if the setup wizard has been run at least once."""
-    return _SETUP_MARKER.exists()
+    return (_resolve_slm_home() / ".setup-complete").exists()
 
 
 def needs_setup() -> bool:
@@ -290,8 +284,9 @@ def _verify_installation() -> bool:
 
 def _mark_complete() -> None:
     """Write .setup-complete marker file."""
-    _SLM_HOME.mkdir(parents=True, exist_ok=True)
-    _SETUP_MARKER.write_text(
+    slm_root = _resolve_slm_home()
+    slm_root.mkdir(parents=True, exist_ok=True)
+    (slm_root / ".setup-complete").write_text(
         f"setup_completed={time.strftime('%Y-%m-%dT%H:%M:%S')}\n"
         f"python={sys.executable}\n"
         f"platform={platform.system()}\n"
@@ -311,6 +306,7 @@ def run_wizard(auto: bool = False) -> None:
               or CI environments).
     """
     interactive = is_interactive() and not auto
+    slm_root = _resolve_slm_home()
 
     print()
     print("╔══════════════════════════════════════════════════════════╗")
@@ -329,7 +325,7 @@ def run_wizard(auto: bool = False) -> None:
     print(f"  Platform: {platform.system()} {platform.machine()}")
     if ram_gb > 0:
         print(f"  RAM:      {ram_gb:.1f} GB {'✓' if ram_gb >= 4 else '⚠ (4GB+ recommended)'}")
-    print(f"  Data dir: {_SLM_HOME}")
+    print(f"  Data dir: {slm_root}")
 
     # Check sentence-transformers
     st_ok = False
@@ -351,8 +347,8 @@ def run_wizard(auto: bool = False) -> None:
     print("─── Step 2/10: Choose Operating Mode ───")
     print()
     print("  [A] Local Guardian (recommended)")
-    print("      Zero cloud. Zero LLM. Full privacy.")
-    print("      EU AI Act compliant. Works immediately.")
+    print("      No model-provider call in the core memory path.")
+    print("      Review optional integrations and network policy for your deployment.")
     print()
     print("  [B] Smart Local")
     print("      Local LLM via Ollama for enrichment.")
@@ -443,8 +439,8 @@ def run_wizard(auto: bool = False) -> None:
     code_graph_enabled = cg_choice in ("", "y", "yes")
 
     # Write code graph config
-    _SLM_HOME.mkdir(parents=True, exist_ok=True)
-    cg_config_path = _SLM_HOME / "code_graph_config.json"
+    slm_root.mkdir(parents=True, exist_ok=True)
+    cg_config_path = slm_root / "code_graph_config.json"
     import json
     cg_config_data = {"enabled": code_graph_enabled, "bridge_enabled": code_graph_enabled}
     cg_config_path.write_text(json.dumps(cg_config_data, indent=2))
@@ -556,7 +552,7 @@ def run_wizard(auto: bool = False) -> None:
             if name in adapters_config:
                 adapters_config[name] = True
 
-    adapters_path = _SLM_HOME / "adapters.json"
+    adapters_path = slm_root / "adapters.json"
     import json as _json
     adapters_path.write_text(_json.dumps(
         {k: {"enabled": v, "tier": "polling"} for k, v in adapters_config.items()},
@@ -613,8 +609,8 @@ def run_wizard(auto: bool = False) -> None:
 
     # Write evolution config to config.json directly
     # (SLMConfig.save() doesn't serialize evolution)
-    _SLM_HOME.mkdir(parents=True, exist_ok=True)
-    evo_config_path = _SLM_HOME / "config.json"
+    slm_root.mkdir(parents=True, exist_ok=True)
+    evo_config_path = slm_root / "config.json"
     evo_cfg: dict = {}
     if evo_config_path.exists():
         try:
@@ -649,7 +645,7 @@ def run_wizard(auto: bool = False) -> None:
             prompt_v3426_options,
             validate_install_data_dir,
         )
-        ok, reason = validate_install_data_dir(_SLM_HOME)
+        ok, reason = validate_install_data_dir(slm_root)
         if not ok:
             print()
             print("  ⚠ Data directory check failed:")
@@ -657,11 +653,16 @@ def run_wizard(auto: bool = False) -> None:
                 print(f"    {line}")
             print()
         v3426_opts = prompt_v3426_options(interactive=interactive)
-        persist_v3426_options(v3426_opts, _SLM_HOME)
+        persist_v3426_options(v3426_opts, slm_root)
     except Exception as exc:
         # Wizard must never crash over an advisory feature.
         print(f"  (v3.4.26 options step skipped: {exc})")
 
+    # External IDE configuration and login-time services cross ownership
+    # boundaries. They require explicit consent even inside the setup wizard.
+    _configure_external_integrations(interactive=interactive)
+    _configure_autostart(interactive=interactive)
+
     # -- Done --
     _mark_complete()
 
@@ -697,18 +698,6 @@ def run_wizard(auto: bool = False) -> None:
     print('    slm recall "search query"')
     print("    slm dashboard              → http://localhost:8765")
     print("    slm adapters enable gmail  → start Gmail ingestion")
-    print()
-    # V3.4.4: Auto-install OS service for daemon persistence (survive reboots)
-    try:
-        from superlocalmemory.cli.service_installer import install_service
-        print("  Installing OS service for auto-start...")
-        if install_service():
-            print("  ✓ SLM will auto-start on login — zero friction.")
-        else:
-            print("  ⚠ OS service not installed (run: slm serve install)")
-    except Exception:
-        print("  ⚠ Could not install OS service (run: slm serve install)")
-
     print()
     print("  Need help?")
     print("    slm doctor     — diagnose issues")
@@ -728,12 +717,14 @@ def check_first_use(command: str) -> None:
     Called from main.py before dispatching any command.
     Skips for commands that don't need setup (setup, hook, --version, --help).
 
-    On first use, also auto-installs Claude Code hooks so pip installs have
-    the same "it just works" experience as npm installs (npm does this via
-    postinstall; pip has no postinstall, so we do it here).
+    First use may initialize SLM-owned defaults, but it never edits an IDE,
+    installs a plugin, or creates an operating-system service. Those external
+    mutations require explicit consent inside ``slm setup``.
     """
     # Commands that work without setup
-    _SKIP_COMMANDS = {"setup", "init", "hook", "hooks", "reap", "mcp"}
+    _SKIP_COMMANDS = {
+        "setup", "init", "hook", "hooks", "reap", "mcp", "diagnostics",
+    }
     if command in _SKIP_COMMANDS:
         return
 
@@ -746,16 +737,15 @@ def check_first_use(command: str) -> None:
     # any lazy-init content (e.g. a pre-existing mode-A skeleton).
     if not is_interactive():
         try:
-            from superlocalmemory.core.config import SLMConfig, DEFAULT_BASE_DIR
+            from superlocalmemory.core.config import SLMConfig
             from superlocalmemory.storage.models import Mode
-            config_path = DEFAULT_BASE_DIR / "config.json"
+            config_path = _resolve_slm_home() / "config.json"
             if not config_path.exists():
                 cfg = SLMConfig.for_mode(Mode.A)
                 cfg.save(mode_change=True)
             _mark_complete()
         except Exception:
             pass
-        _maybe_install_hooks_on_first_use()
         return
 
     # Interactive: run the full wizard
@@ -763,39 +753,49 @@ def check_first_use(command: str) -> None:
     print("  First time using SuperLocalMemory!")
     print("  Running setup wizard...\n")
     run_wizard()
-    _maybe_install_hooks_on_first_use()
 
 
-def _maybe_install_hooks_on_first_use() -> None:
-    """Install Claude Code hooks on first SLM run — matches npm postinstall.
+def _configure_external_integrations(*, interactive: bool) -> bool:
+    """Request consent before editing Claude Code configuration."""
+    print()
+    print("  Optional Claude Code integration can install the SLM plugin and hooks.")
+    if not interactive:
+        print("  Skipped in non-interactive setup. Run: slm connect claude-code")
+        return False
+    choice = _prompt(
+        "  Install Claude Code plugin and hooks now? [y/N] (default: N): ",
+        "n",
+    ).lower()
+    if choice not in ("y", "yes"):
+        print("  Skipped. Run `slm connect claude-code` when ready.")
+        return False
+    return _install_external_integrations()
+
+
+def _install_external_integrations() -> bool:
+    """Install Claude Code hooks/plugin after explicit setup consent.
 
-    Install/uninstall parity rules:
+    Installation rules:
       * Skip if the user explicitly opted out via ``slm hooks remove``
-        (creates ``~/.superlocalmemory/hooks/.hooks-disabled``).
-      * Skip if Claude Code isn't installed (no ``~/.claude/settings.json``
-        to merge into).
-      * Silent + best-effort: never fail a CLI command because of this.
+      * Skip hook configuration if Claude Code has no settings file.
+      * Best-effort: setup remains usable when Claude Code is unavailable.
     """
+    changed = False
     try:
-        opt_out = _SLM_HOME / "hooks" / ".hooks-disabled"
-        if opt_out.exists():
-            return
+        opt_out = _resolve_slm_home() / "hooks" / ".hooks-disabled"
         claude_settings = Path.home() / ".claude" / "settings.json"
-        if not claude_settings.exists():
-            return  # Claude Code not installed — nothing to hook into.
-        from superlocalmemory.hooks.claude_code_hooks import install_hooks
-        install_hooks()
+        if not opt_out.exists() and claude_settings.exists():
+            from superlocalmemory.hooks.claude_code_hooks import install_hooks
+            changed = bool(install_hooks()) or changed
     except Exception:
-        # Best-effort: parity-fallback, never block CLI.
+        # Best-effort: never block setup over an optional integration.
         pass
 
-    # T1-B: Auto-install Claude Code plugin (skills, agents, hooks).
-    # Runs after hooks install, best-effort — never blocks CLI startup.
-    _try_install_claude_plugin()
+    return _try_install_claude_plugin() or changed
 
 
-def _try_install_claude_plugin() -> None:
-    """Auto-install the Claude Code plugin on first pip/uvx SLM install.
+def _try_install_claude_plugin() -> bool:
+    """Install the Claude Code plugin after explicit setup consent.
 
     Runs ``claude plugin marketplace add qualixar/superlocalmemory`` then
     ``claude plugin install superlocalmemory@qualixar`` if the ``claude``
@@ -807,49 +807,94 @@ def _try_install_claude_plugin() -> None:
 
     claude = shutil.which("claude")
     if not claude:
-        return  # Claude Code not in PATH — skip silently
+        print("  Claude Code CLI not found; plugin installation skipped.")
+        return False
 
     _run = lambda cmd: subprocess.run(  # noqa: E731
         cmd, capture_output=True, timeout=30, check=False
     )
 
     try:
-        _run([claude, "plugin", "marketplace", "add", "qualixar/superlocalmemory"])
+        marketplace = _run(
+            [claude, "plugin", "marketplace", "add", "qualixar/superlocalmemory"]
+        )
+        installed = _run(
+            [claude, "plugin", "install", "superlocalmemory@qualixar"]
+        )
+        return marketplace.returncode == 0 and installed.returncode == 0
     except Exception:
-        pass
+        return False
 
+
+def _configure_autostart(*, interactive: bool) -> bool:
+    """Request consent before creating a login-time service definition."""
+    print()
+    print("  Optional auto-start keeps the SLM daemon available after login.")
+    if not interactive:
+        print("  Skipped in non-interactive setup. Run: slm serve install")
+        return False
+    choice = _prompt(
+        "  Install the user-level auto-start service now? [y/N] (default: N): ",
+        "n",
+    ).lower()
+    if choice not in ("y", "yes"):
+        print("  Skipped. Run `slm serve install` when ready.")
+        return False
+    return _install_autostart_service()
+
+
+def _install_autostart_service() -> bool:
+    """Install the user service after explicit setup consent."""
     try:
-        _run([claude, "plugin", "install", "superlocalmemory@qualixar"])
+        from superlocalmemory.cli.service_installer import install_service
+
+        installed = bool(install_service())
+        if installed:
+            print("  ✓ User-level SLM auto-start service installed.")
+        else:
+            print("  ⚠ Service was not installed (run: slm serve install)")
+        return installed
     except Exception:
-        pass
+        print("  ⚠ Service was not installed (run: slm serve install)")
+        return False
 
 
 # ---------------------------------------------------------------------------
 # Mode C provider config (preserved from original)
 # ---------------------------------------------------------------------------
 
-def configure_provider(config: object) -> None:
-    """Configure LLM provider for Mode C."""
+def configure_provider(config: object, provider_name: str | None = None) -> None:
+    """Configure an LLM provider for Mode C.
+
+    When ``provider_name`` is supplied by ``slm provider set <provider>``,
+    configuration is non-interactive and resolves its credential from the
+    provider's documented environment variable. Omitting it preserves the
+    existing interactive picker.
+    """
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.storage.models import Mode
 
     presets = SLMConfig.provider_presets()
 
-    print()
-    print("  Choose your LLM provider:")
-    print()
     providers = list(presets.keys())
-    for i, name in enumerate(providers, 1):
-        preset = presets[name]
-        print(f"    [{i}] {name.capitalize()} — {preset['model']}")
-    print()
+    interactive_selection = provider_name is None
+    if interactive_selection:
+        print()
+        print("  Choose your LLM provider:")
+        print()
+        for i, name in enumerate(providers, 1):
+            preset = presets[name]
+            print(f"    [{i}] {name.capitalize()} — {preset['model']}")
+        print()
 
-    idx = _prompt(f"  Select provider [1-{len(providers)}]: ", "1")
-    try:
-        provider_name = providers[int(idx) - 1]
-    except (ValueError, IndexError):
-        print("  Invalid choice. Using OpenAI.")
-        provider_name = "openai"
+        idx = _prompt(f"  Select provider [1-{len(providers)}]: ", "1")
+        try:
+            provider_name = providers[int(idx) - 1]
+        except (ValueError, IndexError):
+            print("  Invalid choice. Using OpenAI.")
+            provider_name = "openai"
+    elif provider_name not in presets:
+        raise ValueError(f"Unsupported provider: {provider_name}")
 
     preset = presets[provider_name]
 
@@ -861,18 +906,27 @@ def configure_provider(config: object) -> None:
         if existing:
             print(f"  Found {env_key} in environment.")
             api_key = existing
-        elif is_interactive():
+        elif interactive_selection and is_interactive():
             api_key = _prompt(
                 f"  Enter your {provider_name.capitalize()} API key: ",
             )
 
-    updated = SLMConfig.for_mode(
-        Mode.C,
-        llm_provider=provider_name,
-        llm_model=preset["model"],
-        llm_api_key=api_key,
-        llm_api_base=preset["base_url"],
+    # Provider selection is an additive configuration operation.  Rebuilding
+    # via ``for_mode`` used to reset retrieval, scale-engine, evolution, and
+    # user-tuned embedding settings — surprising and unsafe after a user had
+    # configured a local or promoted Cozo/Lance deployment.  Keep every
+    # unrelated setting intact and change only the mode/provider contract.
+    from superlocalmemory.core.config import LLMConfig
+
+    updated = config if isinstance(config, SLMConfig) else SLMConfig.load()
+    updated.mode = Mode.C
+    updated.llm = LLMConfig(
+        provider=provider_name,
+        model=preset["model"],
+        api_key=api_key,
+        api_base=preset["base_url"],
     )
     updated.save(mode_change=True)
+    SLMConfig.write_current_mode(Mode.C, updated.base_dir)
     print(f"  Provider: {provider_name}")
     print(f"  Model: {preset['model']}")

package/src/superlocalmemory/cli/version_banner.py

@@ -28,7 +28,8 @@ _MAX_MARKER_BYTES = 64  # a semver string is ≤ 32 chars; 64 is plenty
 
 
 def _data_dir() -> Path:
-    return Path(os.environ.get("SLM_DATA_DIR") or Path.home() / ".superlocalmemory")
+    from superlocalmemory.infra.data_root import canonical_data_root
+    return canonical_data_root()
 
 
 def _marker_path() -> Path:

package/src/superlocalmemory/code_graph/config.py

@@ -12,6 +12,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 
+from superlocalmemory.infra.data_root import state_path
+
 
 # Languages supported out of the box (tree-sitter grammar names)
 DEFAULT_LANGUAGES: frozenset[str] = frozenset({
@@ -85,4 +87,4 @@ class CodeGraphConfig:
             return self.db_path
         if slm_base_dir is not None:
             return slm_base_dir / "code_graph.db"
-        return Path.home() / ".superlocalmemory" / "code_graph.db"
+        return state_path("code_graph.db")