memorytalk 0.8.2__tar.gz → 0.8.3__tar.gz

{memorytalk-0.8.2 → memorytalk-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorytalk
-Version: 0.8.2
+Version: 0.8.3
 Summary: Persistent cross-session memory for AI agents — Talk-Card architecture with forum-dynamics sinking/floating (v3)
 License-Expression: Apache-2.0
 Requires-Python: >=3.10

{memorytalk-0.8.2 → memorytalk-0.8.3}/memorytalk/cli/_format.py

@@ -48,6 +48,25 @@ def fmt_server_stop(payload: dict) -> str:
     return f"**{status}**\n"
 
 
+def fmt_server_restart(payload: dict) -> str:
+    status = payload.get("status", "")
+    if status == "restarted":
+        return (
+            f"**restarted** · prev pid `{payload.get('previous_pid')}` "
+            f"→ pid `{payload['pid']}` · port `{payload['port']}`\n"
+        )
+    if status == "started":
+        # No previous daemon — restart degenerated into a fresh start.
+        return (
+            f"**started** · pid `{payload['pid']}` · port `{payload['port']}` "
+            "(was not running)\n"
+        )
+    if status == "failed":
+        # Reuse start's failure shape — same fields are populated.
+        return fmt_server_start(payload)
+    return f"**{status}**\n"
+
+
 def fmt_status(payload: dict) -> str:
     if payload.get("status") == "not_running":
         return (

{memorytalk-0.8.2 → memorytalk-0.8.3}/memorytalk/cli/server.py

@@ -14,7 +14,9 @@ from pathlib import Path
 
 import click
 
-from memorytalk.cli._format import fmt_server_start, fmt_server_stop, fmt_status
+from memorytalk.cli._format import (
+    fmt_server_restart, fmt_server_start, fmt_server_stop, fmt_status,
+)
 from memorytalk.cli._http import ApiError, api
 from memorytalk.cli._render import emit_json, emit_md
 from memorytalk.config import Config
@@ -115,6 +117,84 @@ def stop_server_proc(cfg: Config) -> dict:
     return {"status": "stopped", "pid": pid}
 
 
+# Graceful-exit budget after SIGTERM. The lifespan __aexit__ has to
+# stop the sync watcher, drain the IndexWriteBuffer, close the LanceDB
+# connection and shut SQLite down — on a busy install with a half-full
+# buffer that's ~1–3 s typical, with headroom for outliers. After this
+# window we escalate to SIGKILL so ``restart`` never hangs the CLI.
+_RESTART_GRACE_SECONDS = 10.0
+_RESTART_POLL_INTERVAL = 0.1
+
+
+def restart_server_proc(cfg: Config) -> dict:
+    """Stop the running daemon (if any) + wait for graceful exit +
+    start fresh. Returns one of:
+
+        {"status": "restarted",
+         "previous_pid": int, "pid": int, "port": int}
+            — there was a daemon, it died cleanly, new one is up.
+
+        {"status": "started", "pid": int, "port": int}
+            — no daemon was running; same shape as a plain ``start``.
+
+        {"status": "failed",
+         "exit_code": int, "error": str, "previous_pid": int | None}
+            — the *new* daemon failed startup; the previous one is
+              already gone (we don't roll back — leaves logs intact for
+              debugging).
+
+    Waits up to ``_RESTART_GRACE_SECONDS`` for the old process to exit,
+    then SIGKILLs if it's still around. Without this wait, the new
+    daemon races the old one for the TCP port and gets EADDRINUSE.
+    """
+    previous_pid: int | None = None
+    if cfg.pid_path.exists():
+        try:
+            previous_pid = int(cfg.pid_path.read_text().strip())
+        except ValueError:
+            previous_pid = None
+
+    if previous_pid is not None and pid_alive(previous_pid):
+        try:
+            os.kill(previous_pid, signal.SIGTERM)
+        except ProcessLookupError:
+            pass
+        deadline = time.monotonic() + _RESTART_GRACE_SECONDS
+        while time.monotonic() < deadline:
+            if not pid_alive(previous_pid):
+                break
+            time.sleep(_RESTART_POLL_INTERVAL)
+        else:
+            # 10 s and still alive — escalate. SIGKILL is uncatchable;
+            # the kernel reaps the process so ``pid_alive`` flips fast.
+            try:
+                os.kill(previous_pid, signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+            # Tiny window for the kernel to actually reap.
+            time.sleep(0.3)
+
+    # Stale pid/port files would let start_server_proc misread "already
+    # running" — clear them regardless of how we got here.
+    cfg.pid_path.unlink(missing_ok=True)
+    cfg.port_path.unlink(missing_ok=True)
+
+    start_payload = start_server_proc(cfg)
+    status = start_payload.get("status")
+    if status == "failed":
+        return {**start_payload, "previous_pid": previous_pid}
+    if previous_pid is not None:
+        # Distinguish from a fresh start so the user sees "the old
+        # daemon was actually replaced", not just "a daemon started".
+        return {
+            "status": "restarted",
+            "previous_pid": previous_pid,
+            "pid": start_payload["pid"],
+            "port": start_payload["port"],
+        }
+    return start_payload  # status="started" — no previous daemon
+
+
 def _emit(payload: dict, json_out: bool, md_formatter) -> None:
     if json_out:
         emit_json(payload)
@@ -140,6 +220,17 @@ def server_stop(json_out: bool) -> None:
     _emit(payload, json_out, fmt_server_stop)
 
 
+@server.command("restart")
+@click.option("--json", "json_out", is_flag=True, default=False, help="Emit JSON")
+def server_restart(json_out: bool) -> None:
+    """Stop the running daemon (if any) and start it again."""
+    cfg = Config()
+    payload = restart_server_proc(cfg)
+    _emit(payload, json_out, fmt_server_restart)
+    if payload.get("status") == "failed":
+        sys.exit(1)
+
+
 @server.command("status")
 @click.option("--json", "json_out", is_flag=True, default=False, help="Emit JSON")
 def server_status(json_out: bool) -> None:

{memorytalk-0.8.2 → memorytalk-0.8.3}/memorytalk/cli/setup.py

@@ -85,8 +85,11 @@ def _wizard(cfg: Config, old_raw: dict | None, is_first_install: bool) -> dict:
     err_console.print(f"[bold]memory.talk setup[/bold] · {mode}")
     err_console.print(f"data_root: [cyan]{cfg.data_root}[/cyan]\n")
 
-    base = dict(old_raw) if old_raw else Settings().model_dump()
-    new = dict(base)
+    # ``base`` is the raw existing settings.json — NOT a Settings model
+    # dump. Mixing model defaults in would re-introduce the old bug
+    # where wizard-untouched fields (search.ranking_formula etc.) got
+    # materialized to disk and stopped tracking schema-default changes.
+    base = dict(old_raw) if old_raw else {}
 
     # ── embedding ───────────────────────────────────────────────────────
     section("Embedding")
@@ -108,7 +111,6 @@ def _wizard(cfg: Config, old_raw: dict | None, is_first_install: bool) -> dict:
     else:
         emb_base = dict(base.get("embedding") or {})
     emb = _step_embedding(emb_base)
-    new["embedding"] = emb
 
     # Probe the embedding before writing — fail-fast.
     err_console.print("[dim]probing embedding provider...[/dim]")
@@ -117,14 +119,14 @@ def _wizard(cfg: Config, old_raw: dict | None, is_first_install: bool) -> dict:
 
     # ── storage ─────────────────────────────────────────────────────────
     section("Storage")
-    new["vector"] = {"provider": _choice(
+    vector_provider = _choice(
         "vector provider", ["lancedb"],
         (base.get("vector") or {}).get("provider", "lancedb"),
-    )}
-    new["relation"] = {"provider": _choice(
+    )
+    relation_provider = _choice(
         "relation provider", ["sqlite"],
         (base.get("relation") or {}).get("provider", "sqlite"),
-    )}
+    )
 
     # ── server ──────────────────────────────────────────────────────────
     section("Server")
@@ -135,7 +137,6 @@ def _wizard(cfg: Config, old_raw: dict | None, is_first_install: bool) -> dict:
         validate=lambda v: (v.strip().isdigit() and 1 <= int(v) <= 65535)
         or "must be an integer in 1..65535",
     )
-    new["server"] = {"port": int(port_str)}
 
     # ── sync ────────────────────────────────────────────────────────────
     section("Sync")
@@ -149,19 +150,23 @@ def _wizard(cfg: Config, old_raw: dict | None, is_first_install: bool) -> dict:
         "Enable backend sync? (auto-ingest Claude Code / Codex sessions etc.)",
         default=enabled_default,
     )
-    new["sync"] = {
-        "enabled": sync_enabled,
-        "debounce_ms": old_sync.get("debounce_ms", 200),
-    }
 
-    # Carry over sections we don't prompt for (search / recall / explore).
-    # They keep whatever the existing file had; defaults filled in by the
-    # Settings model on first install.
-    for key in ("search", "recall", "explore"):
-        if key in base:
-            new[key] = base[key]
-        else:
-            new[key] = getattr(Settings(), key).model_dump()
+    # ── PATCH onto base ─────────────────────────────────────────────────
+    # Setup writes ONLY the fields it actually prompted for. Anything
+    # else the user had in settings.json — sync.debounce_ms, search.*,
+    # recall.*, explore.*, embedding.batch_size, future fields — is
+    # left untouched. This keeps "defaults that haven't been explicitly
+    # overridden" tracking the Settings schema, so future default
+    # changes (like the 0.8.2 ranking_formula -> "relevance") flow
+    # through on next load without manual intervention.
+    owned = {
+        "server":   {"port": int(port_str)},
+        "vector":   {"provider": vector_provider},
+        "relation": {"provider": relation_provider},
+        "embedding": emb,
+        "sync":     {"enabled": sync_enabled},
+    }
+    new = _patch_owned(base, owned)
 
     # ── diff + persist ──────────────────────────────────────────────────
     diff = diff_settings(base, new)
@@ -228,6 +233,32 @@ def _step_embedding(base: dict) -> dict:
     return out
 
 
+def _patch_owned(base: dict, owned: dict[str, dict]) -> dict:
+    """Apply ``owned`` updates onto ``base`` at field-level granularity.
+
+    For each section in ``owned``:
+      - Merge ``owned[section]`` keys into ``base[section]`` (creating
+        the section if missing).
+      - Keys that are in ``base[section]`` but NOT in ``owned[section]``
+        are preserved as-is.
+
+    Sections that aren't in ``owned`` at all (e.g. ``search``, ``recall``,
+    ``explore``, ``index``) are returned untouched.
+
+    Provider switch (openai → local) note: stale provider-specific
+    keys like ``endpoint`` / ``auth_key`` survive in the file. They're
+    inert when ``provider != "openai"`` (Settings just ignores them on
+    load). Strict patch — wizard owns what wizard prompted for; it
+    doesn't synthesize cleanup of unrelated keys.
+    """
+    new = dict(base)
+    for section, fields in owned.items():
+        section_data = dict(new.get(section, {}))
+        section_data.update(fields)
+        new[section] = section_data
+    return new
+
+
 def _show_detected_endpoints() -> None:
     """List adapters whose ``DEFAULT_LOCATION`` exists on the user's
     machine — those will be auto-attached on server start. Adapters

{memorytalk-0.8.2 → memorytalk-0.8.3}/memorytalk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorytalk
-Version: 0.8.2
+Version: 0.8.3
 Summary: Persistent cross-session memory for AI agents — Talk-Card architecture with forum-dynamics sinking/floating (v3)
 License-Expression: Apache-2.0
 Requires-Python: >=3.10

{memorytalk-0.8.2 → memorytalk-0.8.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "memorytalk"
-version = "0.8.2"
+version = "0.8.3"
 description = "Persistent cross-session memory for AI agents — Talk-Card architecture with forum-dynamics sinking/floating (v3)"
 readme = "README.md"
 requires-python = ">=3.10"