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

{flurryx_code_memory-0.5.2 → flurryx_code_memory-0.6.1}/CHANGELOG.md

@@ -8,6 +8,81 @@ when the repo grows.
 This file complements `git log`: commits explain mechanics, this file
 explains intent.
 
+## [0.6.0] — 2026-06-04
+
+Release theme: **Dart joins the graph, and `this.field.method()` resolves
+across languages**. The extractor gains a ninth language and the
+receiver-type tier — previously TypeScript-only — now narrows method
+calls in C#, PHP, and Dart too.
+
+### Added — Dart / Flutter language support
+
+**What:** `.dart` files are now parsed. Symbols cover classes, mixins,
+enums, extensions, typedefs, top-level functions, methods,
+getters/setters, and constructors (with parameter arity); imports and
+re-exports surface their URI (`package:…`, `dart:…`, relative); calls and
+type references (inheritance, field/parameter/return types, generic
+arguments) are extracted. Dart's grammar differs structurally from the
+other languages — function names follow the return type inside
+`function_signature`, calls are a `selector` + `argument_part` chain
+rather than a single call-expression node, and import URIs are nested
+under `configurable_uri > uri` — so each needed dedicated handling.
+Node-type names that collide with TypeScript (`function_signature`,
+`declaration`, …) are gated on `lang == "dart"` so TS output is
+unchanged.
+
+**Reason:** Flutter/Dart codebases were a blind spot — every `.dart`
+file was skipped at `lang_for`, so half of a mobile + backend stack had
+no graph topology, leaving retrieval to dense vectors alone.
+
+### Added — Cross-language receiver-type inference (C#, PHP, Dart)
+
+**What:** the `this.<field>.<method>()` narrowing that let the resolver
+disambiguate a call against the methods of the field's declared type now
+works beyond TypeScript. The class-scope stack is language-aware: C#
+reads fields, properties, and C# 12 primary-constructor parameters and
+resolves both `_repo.Get()` and `this.Bar.Save()`; PHP reads properties
+and PHP 8 constructor promotion and resolves `$this->repo->m()`; Dart
+reads typed fields and resolves `repo.m()` / `this.repo.m()`. A shared
+`_bare_type_name` reduces qualified / generic / nullable types to the
+bare identifier the resolver matches on, dropping primitives.
+
+**Reason:** the resolver's receiver tier is language-agnostic — it
+matches a bare type name against files defining that symbol — but the
+extractor only ever emitted `receiver_type` for TS. On C#/PHP/Dart, a
+method call like `byId` collapsed to a bare identifier that the resolver
+could never narrow against the dozens of same-named methods elsewhere in
+the codebase. Emitting the inferred receiver type fixes that with no
+resolver changes.
+
+## [0.5.3] — 2026-06-04
+
+Release theme: **git operations never block on credentials**. The
+snapshot store talked to `origin` with plain `git fetch` / `git push`
+and nothing to suppress interactive auth. On any HTTPS remote without
+cached credentials that froze the MCP server at boot and re-prompted on
+every `code-memory status` and watcher tick.
+
+### Fixed — Interactive git credential prompts froze the MCP server
+
+**What:** every best-effort / read git call in `SnapshotStore` (`fetch`,
+listing, the snapshot existence check) now runs with
+`GIT_TERMINAL_PROMPT=0`, `GIT_SSH_COMMAND=ssh -oBatchMode=yes`, and an
+empty `-c credential.helper=` so it fails fast instead of blocking. Only
+the explicit publish path (`push` during `snapshot publish` / `gc`) opts
+back into credentials via `allow_credentials=True`, so opted-in remotes
+still authenticate.
+
+**Reason:** `GIT_TERMINAL_PROMPT=0` alone was not enough — a configured
+credential helper such as Git Credential Manager is a separate program
+git still launches, and it pops its own dialog. The MCP bootstrap runs a
+synchronous `sync_repo(trigger="mcp-boot")` with `fetch=True`; on an
+auth-required remote that `git fetch` hung waiting for a password the
+stdio server could never supply, so OpenCode reported the server as not
+running. The watcher's per-quiet-period sync and `code-memory status`
+hit the same wall. Resetting the helper list makes git return in ~0.1s
+(no remote snapshots) instead of waiting on a human.
+
 ## [0.5.2] — 2026-05-30
 
 Release theme: **the watcher stops leaking**. A diagnosis of runaway RAM

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flurryx-code-memory
-Version: 0.5.2
+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.5.2 → flurryx_code_memory-0.6.1}/README.md

@@ -1772,6 +1772,7 @@ See `CHANGELOG.md` for the design rationale.
 - [x] `code-memory vacuum --before <sha>` / `--older-than` / `--all` (tombstone GC)
 - [x] MCP tools: `codememory_drift`, `codememory_at_sha`, `codememory_callers_at_sha`
 - [x] .NET ecosystem (C#, Razor, VB.NET, F#)
+- [x] Dart / Flutter (classes, mixins, enums, extensions, typedefs, imports/exports, calls, type refs)
 - [ ] More languages (Rust, Go, Java)
 - [ ] Cursor hook recipe
 - [ ] PyPI release (drops the `--from git+…` from the `uvx` install)

flurryx_code_memory-0.6.1/plugins/vibe/README.md

@@ -0,0 +1,117 @@
+# @code-memory/vibe-plugin
+
+Mistral Vibe plugin that wires the [`code-memory`](../..) backend into Vibe.
+Same spirit as the [Claude Code](../claude-code/README.md),
+[Cursor](../cursor/README.md), and [OpenCode](../opencode/README.md) plugins,
+adapted to what Vibe actually exposes.
+
+## The honest mapping
+
+Vibe is extensible through **Skills**, **MCP servers**, **custom agents**, and
+**custom prompts** — but it has **no lifecycle-hook API**. The Claude Code and
+Cursor plugins lean on hooks (`sessionStart`, `postToolUse`, `afterFileEdit`,
+`stop`, `preCompact`, …) for per-turn automation: auto-reingest on write,
+episode recording on stop, the retrieve-before-grep nudge. None of that can
+fire from inside Vibe.
+
+So this plugin delivers the same capability through the surfaces Vibe has:
+
+| code-memory plugin piece                       | Vibe equivalent                                            |
+| ----------------------------------------------- | ---------------------------------------------------------- |
+| MCP server (`codememory_*` tools)               | `[[mcp_servers]]` block in `config.toml`                   |
+| `/code-memory` slash command                    | `skills/code-memory/SKILL.md` (`user-invocable: true`)     |
+| Context rule (retrieve-before-grep steering)    | The same skill's body — standing orientation guidance      |
+| `afterFileEdit` → auto-reingest hook            | **OS autostart watcher** (`code-memory autostart install`) |
+| `sessionStart` / `stop` / `preCompact` episodes | _no equivalent_ — drive `code-memory record` manually      |
+
+The OS watcher is harness-independent, so it covers the file-edit → reingest
+loop that Vibe cannot hook. Episode recording on session events has no host
+trigger; use `/code-memory` or the CLI to record manually when it matters.
+
+## What it installs
+
+1. **Skill** at `<vibe>/skills/code-memory/SKILL.md` — auto-discovered,
+   exposed as `/code-memory`, and read as orientation guidance that steers the
+   agent to the index first.
+2. **MCP server** — a managed `[[mcp_servers]]` block in `config.toml`
+   spawning `code-memory-mcp` via `uvx`.
+3. **OS autostart watcher** for the current repo, unless `--no-watch`.
+
+## Requirements
+
+1. **`uvx`** (from [uv](https://docs.astral.sh/uv/)) on PATH, to spawn the MCP
+   server. `pipx install uv` / `brew install uv` / `curl -LsSf https://astral.sh/uv/install.sh | sh`.
+2. **`code-memory` CLI** on PATH (for `/code-memory` and the watcher):
+   ```bash
+   pipx install git+https://github.com/fmflurry/code-memory
+   #   or
+   uv tool install git+https://github.com/fmflurry/code-memory
+   ```
+3. **Running infra**: FalkorDB + Qdrant + Ollama with `bge-m3`. See the main
+   [README](../../README.md#installation).
+4. The repo must have been ingested at least once:
+   ```bash
+   code-memory ingest /path/to/repo
+   ```
+
+## Install
+
+```bash
+# user scope (default) — writes ${VIBE_HOME:-~/.vibe}/config.toml + skills/
+./plugins/vibe/install.sh
+
+# project scope — writes ./.vibe/config.toml + skills/
+./plugins/vibe/install.sh --scope project
+
+# skip MCP server registration
+./plugins/vibe/install.sh --no-mcp
+
+# skip the OS autostart watcher
+./plugins/vibe/install.sh --no-watch
+
+# remove the skill, our MCP block, and the watcher
+./plugins/vibe/install.sh --uninstall
+```
+
+The installer:
+- Copies the skill into `<vibe>/skills/code-memory/`.
+- Appends a managed `code-memory` `[[mcp_servers]]` block to `config.toml`
+  between sentinel comments — foreign config is preserved, re-running replaces
+  only our block.
+- Installs the OS autostart watcher for the current repo.
+
+**Restart Vibe** after installing so it re-scans skills + MCP servers.
+
+## The MCP block
+
+```toml
+# >>> code-memory (managed by plugins/vibe/install.sh) >>>
+[[mcp_servers]]
+name = "code-memory"
+transport = "stdio"
+command = "uvx"
+args = ["--from", "git+https://github.com/fmflurry/code-memory", "code-memory-mcp"]
+# <<< code-memory <<<
+```
+
+The server auto-detects the project slug from its working directory
+(`detect_project_slug()`), so no environment variable is required. Each
+`codememory_*` tool still takes an explicit `project` argument — the repo-root
+basename, never `auto`/`default`.
+
+## Verify locally
+
+```bash
+# Skill is discovered + slash command exists
+ls "${VIBE_HOME:-$HOME/.vibe}/skills/code-memory/SKILL.md"
+
+# MCP block is present
+grep -A6 'code-memory (managed' "${VIBE_HOME:-$HOME/.vibe}/config.toml"
+
+# Watcher is registered for this repo
+code-memory autostart status .
+```
+
+## License
+
+MIT — see [LICENSE](../../LICENSE).

flurryx_code_memory-0.6.1/plugins/vibe/install.sh

@@ -0,0 +1,184 @@
+#!/usr/bin/env bash
+# Install the code-memory Mistral Vibe plugin.
+#
+# Mistral Vibe has no lifecycle-hook API (unlike Claude Code / Cursor), so this
+# plugin wires code-memory in through the three surfaces Vibe *does* expose:
+#
+#   1. A Skill (skills/code-memory/SKILL.md) — auto-discovered, exposed as the
+#      `/code-memory` slash command, and standing orientation guidance that
+#      steers the agent toward the index before grep/read/shell.
+#   2. The code-memory MCP server, registered as a managed `[[mcp_servers]]`
+#      block in config.toml (exposes the `codememory_*` tools).
+#   3. The OS-level autostart watcher (`code-memory autostart install`) — the
+#      background auto-reingest that replaces the per-turn hooks Vibe lacks.
+#
+# Vibe reads config + skills from:
+#   - user scope:    ${VIBE_HOME:-~/.vibe}/{config.toml,skills/}
+#   - project scope: <cwd>/.vibe/{config.toml,skills/}
+#
+# All operations are idempotent. The MCP entry lives between sentinel comments
+# so re-running replaces only our block and leaves foreign config untouched.
+#
+# Flags:
+#   --scope X    user (default) | project
+#   --no-mcp     skip MCP server registration
+#   --no-watch   skip installing the OS autostart watcher
+#   --uninstall  remove the skill, our MCP block, and the watcher
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+PLUGIN_DIR="$REPO_ROOT/plugins/vibe"
+SKILL_SRC="$PLUGIN_DIR/skills/code-memory"
+
+[[ -f "$SKILL_SRC/SKILL.md" ]] || {
+  echo "✗ Missing skills/code-memory/SKILL.md — repo layout broken." >&2
+  exit 1
+}
+
+SCOPE="user"
+SKIP_MCP=0
+SKIP_WATCH=0
+UNINSTALL=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --scope)     SCOPE="$2"; shift 2 ;;
+    --no-mcp)    SKIP_MCP=1; shift ;;
+    --no-watch)  SKIP_WATCH=1; shift ;;
+    --uninstall) UNINSTALL=1; shift ;;
+    -h|--help)
+      cat <<EOF
+Usage: $0 [--scope user|project] [--no-mcp] [--no-watch] [--uninstall]
+
+  --scope X    user (default — writes \${VIBE_HOME:-~/.vibe}/) | project (./.vibe/)
+  --no-mcp     skip MCP server registration in config.toml
+  --no-watch   skip installing the OS autostart watcher
+  --uninstall  remove the skill, our config.toml MCP block, and the watcher
+
+The installer copies the code-memory skill, merges a managed code-memory MCP
+block into config.toml (preserving foreign config), and installs the OS
+autostart watcher so file edits are re-ingested in the background — Vibe has
+no hooks to do that per-turn.
+EOF
+      exit 0
+      ;;
+    *)
+      echo "Unknown flag: $1" >&2
+      exit 2
+      ;;
+  esac
+done
+
+case "$SCOPE" in
+  user)    TARGET_DIR="${VIBE_HOME:-$HOME/.vibe}" ;;
+  project) TARGET_DIR="$(pwd)/.vibe" ;;
+  *)
+    echo "✗ --scope must be user or project (got: $SCOPE)" >&2
+    exit 2
+    ;;
+esac
+
+CONFIG_FILE="$TARGET_DIR/config.toml"
+SKILL_DST="$TARGET_DIR/skills/code-memory"
+BEGIN_MARK="# >>> code-memory (managed by plugins/vibe/install.sh) >>>"
+END_MARK="# <<< code-memory <<<"
+
+# Strip our managed block from config.toml (in place, leaving a trailing
+# newline). No-op if the file or block is absent.
+strip_mcp_block() {
+  [[ -f "$CONFIG_FILE" ]] || return 0
+  local tmp
+  tmp="$(mktemp)"
+  awk -v b="$BEGIN_MARK" -v e="$END_MARK" '
+    $0 == b { skip = 1; next }
+    $0 == e { skip = 0; next }
+    !skip   { print }
+  ' "$CONFIG_FILE" > "$tmp"
+  mv "$tmp" "$CONFIG_FILE"
+}
+
+# --------------------------------------------------------------- uninstall
+if [[ "$UNINSTALL" -eq 1 ]]; then
+  strip_mcp_block
+  [[ -f "$CONFIG_FILE" ]] && echo "✓ removed code-memory MCP block from $CONFIG_FILE"
+  rm -rf "$SKILL_DST"
+  echo "✓ removed $SKILL_DST"
+  if [[ "$SKIP_WATCH" -eq 0 ]] && command -v code-memory >/dev/null 2>&1; then
+    code-memory autostart uninstall "$(pwd)" >/dev/null 2>&1 \
+      && echo "✓ removed OS autostart watcher for $(pwd)" \
+      || echo "↪ no autostart watcher to remove (or removal failed)"
+  fi
+  echo "Done. Restart Vibe to pick up the change."
+  exit 0
+fi
+
+# --------------------------------------------------------------- install
+echo "→ Target: $TARGET_DIR (scope=$SCOPE)"
+mkdir -p "$TARGET_DIR/skills"
+
+# 1) Install the skill
+rm -rf "$SKILL_DST"
+mkdir -p "$SKILL_DST"
+cp "$SKILL_SRC/SKILL.md" "$SKILL_DST/SKILL.md"
+echo "✓ wrote $SKILL_DST/SKILL.md"
+
+# 2) MCP server registration (managed block)
+if [[ "$SKIP_MCP" -eq 0 ]]; then
+  if ! command -v uvx >/dev/null 2>&1; then
+    cat >&2 <<EOF
+⚠  uvx not on PATH. The MCP block will still be written but Vibe will fail to
+   spawn code-memory-mcp until you install uv:
+     pipx install uv     |     brew install uv
+     pip3 install --user uv     |     curl -LsSf https://astral.sh/uv/install.sh | sh
+EOF
+  fi
+  mkdir -p "$TARGET_DIR"
+  strip_mcp_block
+  # Ensure a clean separator before appending.
+  if [[ -s "$CONFIG_FILE" ]]; then printf '\n' >> "$CONFIG_FILE"; fi
+  cat >> "$CONFIG_FILE" <<EOF
+$BEGIN_MARK
+[[mcp_servers]]
+name = "code-memory"
+transport = "stdio"
+command = "uvx"
+args = ["--from", "git+https://github.com/fmflurry/code-memory", "code-memory-mcp"]
+$END_MARK
+EOF
+  echo "✓ wrote $CONFIG_FILE (code-memory MCP block)"
+else
+  echo "↪ skipped MCP registration (--no-mcp)"
+fi
+
+# 3) OS autostart watcher — the per-turn-hook replacement
+if [[ "$SKIP_WATCH" -eq 0 ]]; then
+  if command -v code-memory >/dev/null 2>&1; then
+    if code-memory autostart install "$(pwd)" >/dev/null 2>&1; then
+      echo "✓ installed OS autostart watcher for $(pwd)"
+    else
+      echo "⚠ could not install autostart watcher (run: code-memory autostart install .)"
+    fi
+  else
+    echo "↪ skipped watcher — code-memory CLI not on PATH"
+  fi
+else
+  echo "↪ skipped autostart watcher (--no-watch)"
+fi
+
+# 4) CLI presence check
+echo
+if command -v code-memory >/dev/null 2>&1; then
+  echo "✓ \`code-memory\` CLI on PATH: $(command -v code-memory)"
+else
+  cat <<EOF
+⚠  \`code-memory\` CLI is NOT on PATH. The skill + MCP server still load, but
+   the /code-memory command and the watcher need it:
+
+     pipx install git+https://github.com/fmflurry/code-memory
+     uv tool install git+https://github.com/fmflurry/code-memory
+EOF
+fi
+
+echo
+echo "Done. Restart Vibe so it picks up the new skill + MCP server."

flurryx_code_memory-0.6.1/plugins/vibe/skills/code-memory/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: code-memory
+description: Orient on the codebase via the code-memory MCP index before grep/read/shell, and drive the backend manually (retrieve / record / reingest / ingest).
+user-invocable: true
+---
+
+# code-memory: retrieve before grep
+
+For any question that maps to "where is X / how does Y work / who calls Z /
+where do docs live / what depends on this", call the `code-memory` MCP tools
+**before** grep, glob, read, or shell. The index is faster, ranked, and aware
+of past episodes + durable user claims.
+
+Mistral Vibe has no lifecycle hooks, so the per-turn automation that the Claude
+Code / Cursor plugins get for free does not fire here. This skill is the
+standing instruction that replaces it: you drive the index explicitly.
+
+## Pick the right tool
+
+- `codememory_retrieve` — semantic + episodic recall. Default first call for
+  any natural-language code question.
+- `codememory_definitions(symbol)` — exact file + line for a name.
+- `codememory_callers(symbol)` / `codememory_callees(symbol)` — call graph
+  (rename impact, dependency mapping).
+- `codememory_importers(target)` / `codememory_dependencies(file)` — module
+  import graph.
+- `codememory_at_sha`, `codememory_callers_at_sha`, `codememory_drift` —
+  temporal queries (what existed at a past commit, what's stale).
+- `codememory_assert_claim` — record durable user assertions (preferences,
+  decisions, rejections, ownership, location).
+
+Every tool takes a required `project` argument: the repo slug, which is the
+basename of the repo root directory (e.g. `code-memory` for
+`/Users/you/Workspace/code-memory`). Do not pass `auto` or `default` — they are
+rejected.
+
+## Workflow
+
+1. Read the question. If it's about repo / code / docs structure, call the
+   matching code-memory tool first.
+2. Use filesystem tools (read / grep / shell) only to verify or read specific
+   files the index pointed to.
+3. After completing a non-trivial task, call `codememory_record(prompt, plan,
+   patch, verdict)` so the next session can recall what worked.
+4. When the user states a preference, decision, or rejection, call
+   `codememory_assert_claim` to make it durable.
+
+Default to one targeted MCP call over a wide grep. Read source files only after
+the graph tells you exactly which lines to open.
+
+## Driving the backend manually
+
+The CLI covers the paths Vibe cannot hook. Run these via shell when needed:
+
+- Force a retrieval: `code-memory retrieve "rotate refresh tokens" --json`
+- Record an episode: `code-memory record --prompt "..." --verdict success`
+- Refresh a stale index after an out-of-band edit: `code-memory ingest .`
+- Re-point cross-file CALLS edges: `code-memory resolve`
+
+If the OS watcher is installed (`code-memory autostart status`), file edits are
+re-ingested automatically in the background and you rarely need step 3's manual
+`ingest`. If it is not running, re-ingest after a batch of writes.

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flurryx-code-memory"
-version = "0.5.2"
+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.5.2 → 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 {
@@ -267,6 +283,7 @@ Step "Agent harness plugins"
 $installOpencode   = $false
 $installClaudecode = $false
 $installCursor     = $false
+$installVibe       = $false
 
 function Resolve-PluginSelection([string]$raw) {
   if ([string]::IsNullOrWhiteSpace($raw)) { return }
@@ -275,18 +292,22 @@ function Resolve-PluginSelection([string]$raw) {
     $script:installOpencode = $true
     $script:installClaudecode = $true
     $script:installCursor = $true
+    $script:installVibe = $true
     return
   }
   foreach ($p in $raw.Split(',')) {
     $key = $p.Trim().ToLower()
     switch ($key) {
-      'opencode'    { $script:installOpencode = $true }
-      'claudecode'  { $script:installClaudecode = $true }
-      'claude'      { $script:installClaudecode = $true }
-      'claude-code' { $script:installClaudecode = $true }
-      'cursor'      { $script:installCursor = $true }
-      ''            { }
-      default       { Warn "unknown plugin '$p' (expected: opencode, claudecode, cursor, all, none)" }
+      'opencode'     { $script:installOpencode = $true }
+      'claudecode'   { $script:installClaudecode = $true }
+      'claude'       { $script:installClaudecode = $true }
+      'claude-code'  { $script:installClaudecode = $true }
+      'cursor'       { $script:installCursor = $true }
+      'vibe'         { $script:installVibe = $true }
+      'mistral'      { $script:installVibe = $true }
+      'mistral-vibe' { $script:installVibe = $true }
+      ''             { }
+      default        { Warn "unknown plugin '$p' (expected: opencode, claudecode, cursor, vibe, all, none)" }
     }
   }
 }
@@ -300,8 +321,9 @@ if (-not [string]::IsNullOrWhiteSpace($Plugins)) {
   if (Prompt-YesNo "Install OpenCode plugin?" $true)    { $installOpencode = $true }
   if (Prompt-YesNo "Install Claude Code plugin?" $true) { $installClaudecode = $true }
   if (Prompt-YesNo "Install Cursor plugin?" $true)      { $installCursor = $true }
-  if (($installOpencode -or $installClaudecode -or $installCursor) -and $PluginsScope -eq 'global') {
-    if (Prompt-YesNo "Install project-local (./.opencode, ./.claude, ./.cursor) instead of global?" $false) {
+  if (Prompt-YesNo "Install Mistral Vibe plugin?" $true) { $installVibe = $true }
+  if (($installOpencode -or $installClaudecode -or $installCursor -or $installVibe) -and $PluginsScope -eq 'global') {
+    if (Prompt-YesNo "Install project-local (./.opencode, ./.claude, ./.cursor, ./.vibe) instead of global?" $false) {
       $PluginsScope = 'project'
     }
   }
@@ -349,8 +371,11 @@ if ($installClaudecode) {
 if ($installCursor) {
   Invoke-PluginInstaller 'plugins/cursor/install.sh' 'Cursor' 'scope'
 }
-if (-not $installOpencode -and -not $installClaudecode -and -not $installCursor) {
-  Warn "no harness plugin installed; re-run with -Plugins all (or =opencode/=claudecode/=cursor) later"
+if ($installVibe) {
+  Invoke-PluginInstaller 'plugins/vibe/install.sh' 'Mistral Vibe' 'scope'
+}
+if (-not $installOpencode -and -not $installClaudecode -and -not $installCursor -and -not $installVibe) {
+  Warn "no harness plugin installed; re-run with -Plugins all (or =opencode/=claudecode/=cursor/=vibe) later"
 }
 
 # ---------- done ----------

{flurryx_code_memory-0.5.2 → 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"
@@ -326,10 +340,11 @@ step "Agent harness plugins"
 #   PLUGINS_ARG="" → interactive (only if stdin is a TTY)
 #   PLUGINS_ARG="none" → skip
 #   PLUGINS_ARG="all" → both
-#   PLUGINS_ARG="opencode,claudecode,cursor" → comma-separated whitelist
+#   PLUGINS_ARG="opencode,claudecode,cursor,vibe" → comma-separated whitelist
 INSTALL_OPENCODE=0
 INSTALL_CLAUDECODE=0
 INSTALL_CURSOR=0
+INSTALL_VIBE=0
 
 resolve_plugin_selection() {
   local raw="$1"
@@ -338,6 +353,7 @@ resolve_plugin_selection() {
     INSTALL_OPENCODE=1
     INSTALL_CLAUDECODE=1
     INSTALL_CURSOR=1
+    INSTALL_VIBE=1
     return 0
   fi
   IFS=',' read -r -a parts <<< "$raw"
@@ -346,8 +362,9 @@ resolve_plugin_selection() {
       opencode)   INSTALL_OPENCODE=1 ;;
       claudecode|claude|claude-code) INSTALL_CLAUDECODE=1 ;;
       cursor)     INSTALL_CURSOR=1 ;;
+      vibe|mistral|mistral-vibe) INSTALL_VIBE=1 ;;
       "" ) ;;
-      *) warn "unknown plugin '$p' (expected: opencode, claudecode, cursor, all, none)" ;;
+      *) warn "unknown plugin '$p' (expected: opencode, claudecode, cursor, vibe, all, none)" ;;
     esac
   done
 }
@@ -361,8 +378,9 @@ elif [ -t 0 ] && [ -t 1 ]; then
   if prompt_yes_no "Install OpenCode plugin?" "y"; then INSTALL_OPENCODE=1; fi
   if prompt_yes_no "Install Claude Code plugin?" "y"; then INSTALL_CLAUDECODE=1; fi
   if prompt_yes_no "Install Cursor plugin?" "y"; then INSTALL_CURSOR=1; fi
-  if [ "$INSTALL_OPENCODE" -eq 1 ] || [ "$INSTALL_CLAUDECODE" -eq 1 ] || [ "$INSTALL_CURSOR" -eq 1 ]; then
-    if prompt_yes_no "Install project-local (./.opencode, ./.claude, ./.cursor) instead of global?" "n"; then
+  if prompt_yes_no "Install Mistral Vibe plugin?" "y"; then INSTALL_VIBE=1; fi
+  if [ "$INSTALL_OPENCODE" -eq 1 ] || [ "$INSTALL_CLAUDECODE" -eq 1 ] || [ "$INSTALL_CURSOR" -eq 1 ] || [ "$INSTALL_VIBE" -eq 1 ]; then
+    if prompt_yes_no "Install project-local (./.opencode, ./.claude, ./.cursor, ./.vibe) instead of global?" "n"; then
       PLUGINS_SCOPE="project"
     fi
   fi
@@ -411,8 +429,22 @@ if [ "$INSTALL_CURSOR" -eq 1 ]; then
   fi
 fi
 
-if [ "$INSTALL_OPENCODE" -eq 0 ] && [ "$INSTALL_CLAUDECODE" -eq 0 ] && [ "$INSTALL_CURSOR" -eq 0 ]; then
-  warn "no harness plugin installed; re-run with --plugins=all (or =opencode/=claudecode/=cursor) later"
+if [ "$INSTALL_VIBE" -eq 1 ]; then
+  if [ -x "$PROJECT_ROOT/plugins/vibe/install.sh" ]; then
+    # The vibe installer uses `--scope user|project`, like cursor.
+    vibe_flags=""
+    [ "$PLUGINS_SCOPE" = "project" ] && vibe_flags="$vibe_flags --scope project"
+    [ "$SKIP_MCP" -eq 1 ] && vibe_flags="$vibe_flags --no-mcp"
+    # shellcheck disable=SC2086 # intentional word-splitting on flag string
+    "$PROJECT_ROOT/plugins/vibe/install.sh" $vibe_flags
+    ok "Mistral Vibe plugin installed ($PLUGINS_SCOPE)"
+  else
+    warn "plugins/vibe/install.sh not executable; skipping"
+  fi
+fi
+
+if [ "$INSTALL_OPENCODE" -eq 0 ] && [ "$INSTALL_CLAUDECODE" -eq 0 ] && [ "$INSTALL_CURSOR" -eq 0 ] && [ "$INSTALL_VIBE" -eq 0 ]; then
+  warn "no harness plugin installed; re-run with --plugins=all (or =opencode/=claudecode/=cursor/=vibe) later"
 fi
 
 # ---------- done ----------