flurryx-code-memory 0.6.0__tar.gz → 0.6.1__tar.gz

{flurryx_code_memory-0.6.0 → flurryx_code_memory-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flurryx-code-memory
-Version: 0.6.0
+Version: 0.6.1
 Summary: Local lightweight memory layer for coding agents: FalkorDB + Qdrant + Ollama (BGE-M3) + tree-sitter
 Requires-Python: >=3.11
 Requires-Dist: anyio>=4.4

{flurryx_code_memory-0.6.0 → flurryx_code_memory-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flurryx-code-memory"
-version = "0.6.0"
+version = "0.6.1"
 description = "Local lightweight memory layer for coding agents: FalkorDB + Qdrant + Ollama (BGE-M3) + tree-sitter"
 requires-python = ">=3.11"
 dependencies = [

{flurryx_code_memory-0.6.0 → flurryx_code_memory-0.6.1}/scripts/install.ps1

@@ -204,9 +204,25 @@ if (-not (Test-Path '.env')) {
 # ---------- 5. docker infra ----------
 if (-not $NoDocker) {
   Step "Starting FalkorDB + Qdrant (docker compose)"
-  & docker compose -f docker/docker-compose.yml up -d
-  if ($LASTEXITCODE -ne 0) { Die "docker compose up failed" }
-  Ok "Containers up"
+  # Pin an explicit project name. The compose file uses fixed container_names
+  # (cm-falkordb, ...), so they are global singletons: a later `compose up`
+  # under a different project name collides with "container name already in
+  # use". Reuse whatever project already owns the running containers (so their
+  # data volumes, namespaced as <project>_falkor_data, stay attached); fall
+  # back to a stable name for fresh installs. This keeps install and
+  # `code-memory update` on one project without ever orphaning indexed data.
+  $CmProject = (& docker inspect -f '{{ index .Config.Labels "com.docker.compose.project" }}' cm-falkordb 2>$null)
+  if (-not $CmProject) { $CmProject = (& docker inspect -f '{{ index .Config.Labels "com.docker.compose.project" }}' cm-qdrant 2>$null) }
+  if (-not $CmProject) { $CmProject = "code-memory" }
+  $CmProject = "$CmProject".Trim()
+  & docker compose -p $CmProject -f docker/docker-compose.yml up -d --remove-orphans
+  if ($LASTEXITCODE -ne 0) {
+    Warn "compose up hit a container-name conflict — removing stale cm-* containers and retrying (named volumes persist)"
+    & docker rm -f cm-falkordb cm-qdrant cm-tei *> $null
+    & docker compose -p $CmProject -f docker/docker-compose.yml up -d --remove-orphans
+    if ($LASTEXITCODE -ne 0) { Die "docker compose up failed" }
+  }
+  Ok "Containers up (project: $CmProject)"
   Dim "FalkorDB browser: http://localhost:3000"
   Dim "Qdrant dashboard: http://localhost:6333/dashboard"
 } else {

{flurryx_code_memory-0.6.0 → flurryx_code_memory-0.6.1}/scripts/install.sh

@@ -220,8 +220,22 @@ fi
 # ---------- 5. docker infra ----------
 if [ "$SKIP_DOCKER" -eq 0 ]; then
   step "Starting FalkorDB + Qdrant (docker compose)"
-  docker compose -f docker/docker-compose.yml up -d
-  ok "Containers up"
+  # Pin an explicit project name. The compose file uses fixed container_names
+  # (cm-falkordb, ...), so they are global singletons: a later `compose up`
+  # under a different project name collides with "container name already in
+  # use". Reuse whatever project already owns the running containers (so their
+  # data volumes, namespaced as <project>_falkor_data, stay attached); fall
+  # back to a stable name for fresh installs. This keeps install and
+  # `code-memory update` on one project without ever orphaning indexed data.
+  CM_PROJECT="$(docker inspect -f '{{ index .Config.Labels "com.docker.compose.project" }}' cm-falkordb 2>/dev/null || true)"
+  [ -z "$CM_PROJECT" ] && CM_PROJECT="$(docker inspect -f '{{ index .Config.Labels "com.docker.compose.project" }}' cm-qdrant 2>/dev/null || true)"
+  [ -z "$CM_PROJECT" ] && CM_PROJECT="code-memory"
+  if ! docker compose -p "$CM_PROJECT" -f docker/docker-compose.yml up -d --remove-orphans; then
+    warn "compose up hit a container-name conflict — removing stale cm-* containers and retrying (named volumes persist)"
+    docker rm -f cm-falkordb cm-qdrant cm-tei >/dev/null 2>&1 || true
+    docker compose -p "$CM_PROJECT" -f docker/docker-compose.yml up -d --remove-orphans || die "docker compose up failed"
+  fi
+  ok "Containers up (project: $CM_PROJECT)"
   printf "${DIM}  FalkorDB browser: http://localhost:3000\n  Qdrant dashboard: http://localhost:6333/dashboard${RST}\n"
 else
   warn "Docker step skipped"

{flurryx_code_memory-0.6.0 → flurryx_code_memory-0.6.1}/src/code_memory/updater.py

@@ -42,6 +42,16 @@ DEFAULT_REPO_URL = os.environ.get(
 )
 CODEMEMORY_HOME = Path(os.environ.get("CODEMEMORY_HOME", str(Path.home() / ".code-memory")))
 
+# Stable compose project name. The compose file pins fixed container_names
+# (``cm-falkordb`` etc.), so the containers are global singletons: only the
+# compose project that originally created them may recreate them. If a later
+# ``compose up`` runs under a *different* project name, Docker refuses with
+# "container name already in use". We therefore always pin ``-p`` to one
+# constant and, when containers already exist, to whatever project actually
+# owns them — so update never collides with install.
+COMPOSE_PROJECT = "code-memory"
+COMPOSE_CONTAINERS = ("cm-falkordb", "cm-qdrant", "cm-tei")
+
 InstallMethod = Literal["uv-tool", "pipx", "pip", "editable", "unknown"]
 
 
@@ -83,8 +93,17 @@ class UpdatePlan:
 
 
 def _run(cmd: list[str], *, check: bool = False, capture: bool = True) -> subprocess.CompletedProcess[str]:
+    # On Windows the CLIs we shell out to (npm, claude) ship as .cmd batch
+    # files. CreateProcess only resolves .exe images by the bare name, so
+    # ``["npm", ...]`` raises WinError 2 even though it is on PATH. Resolve the
+    # real path via PATHEXT-aware which(), and run batch files through cmd.exe.
+    resolved = shutil.which(cmd[0]) or cmd[0]
+    args = [resolved, *cmd[1:]]
+    if os.name == "nt" and resolved.lower().endswith((".cmd", ".bat")):
+        comspec = os.environ.get("COMSPEC", "cmd.exe")
+        args = [comspec, "/c", *args]
     return subprocess.run(
-        cmd, check=check, capture_output=capture, text=True, env={**os.environ}
+        args, check=check, capture_output=capture, text=True, env={**os.environ}
     )
 
 
@@ -203,6 +222,44 @@ def _running_compose_file() -> Path | None:
     return None
 
 
+def _owning_compose_project() -> str | None:
+    """Compose project name that already owns the cm-* containers, if any.
+
+    Reading the live ``com.docker.compose.project`` label lets the updater
+    recreate the existing containers under their original project instead of
+    guessing a name from a directory basename (which is what caused the
+    "container name already in use" conflict).
+    """
+    if not _have("docker"):
+        return None
+    for name in ("cm-falkordb", "cm-qdrant"):
+        p = _run([
+            "docker",
+            "inspect",
+            "-f",
+            "{{ index .Config.Labels \"com.docker.compose.project\" }}",
+            name,
+        ])
+        if p.returncode == 0:
+            proj = p.stdout.strip()
+            if proj:
+                return proj
+    return None
+
+
+def _remove_conflicting_containers() -> None:
+    """Force-remove the fixed-name cm-* containers.
+
+    Last-resort recovery when ``compose up`` still hits a name conflict (e.g.
+    the existing containers carry no compose project label, or an unmanaged
+    container squatted the name). Named volumes (falkor_data, qdrant_data,
+    tei_data) survive ``rm``, so indexed data is preserved.
+    """
+    if not _have("docker"):
+        return
+    _run(["docker", "rm", "-f", *COMPOSE_CONTAINERS])
+
+
 def _claude_plugin_present() -> bool:
     if not _have("claude"):
         return False
@@ -338,24 +395,40 @@ def upgrade_docker_images() -> tuple[bool, str]:
     if not _have("docker"):
         return False, "docker not on PATH"
     compose = CODEMEMORY_HOME / "docker" / "docker-compose.yml"
-    project_dir = CODEMEMORY_HOME
     if not compose.exists():
         live = _running_compose_file()
         if live is None:
             return False, "no compose file at ~/.code-memory/ and no running cm-* containers"
         compose = live
-        project_dir = live.parent
-    pull = _run(
-        ["docker", "compose", "-f", str(compose), "--project-directory", str(project_dir), "pull"],
-        capture=False,
-    )
+    project_dir = compose.parent
+
+    # Pin the project name so naming never depends on the directory basename.
+    # Prefer the project the running containers already belong to — that is the
+    # only project allowed to recreate the fixed-name cm-* containers, so using
+    # it sidesteps the "container name already in use" conflict.
+    project = _owning_compose_project() or COMPOSE_PROJECT
+
+    base = [
+        "docker", "compose",
+        "-f", str(compose),
+        "--project-directory", str(project_dir),
+        "-p", project,
+    ]
+
+    pull = _run([*base, "pull"], capture=False)
     if pull.returncode != 0:
         return False, "docker compose pull failed"
-    up = _run(
-        ["docker", "compose", "-f", str(compose), "--project-directory", str(project_dir), "up", "-d"],
-        capture=False,
-    )
-    return up.returncode == 0, f"compose pulled + up ({compose})"
+
+    up = _run([*base, "up", "-d", "--remove-orphans"], capture=False)
+    if up.returncode == 0:
+        return True, f"compose pulled + up (project={project}, {compose})"
+
+    # Recovery: a stale or unmanaged container is squatting the fixed name.
+    # Drop the cm-* containers (named volumes persist) and recreate cleanly.
+    print("  Docker: name conflict — removing stale cm-* containers and retrying")
+    _remove_conflicting_containers()
+    up_retry = _run([*base, "up", "-d", "--remove-orphans"], capture=False)
+    return up_retry.returncode == 0, f"compose recreated after conflict (project={project}, {compose})"
 
 
 def upgrade_ollama_model(model: str) -> tuple[bool, str]: