memory-bank-skill 3.0.0__py3-none-any.whl

memory_bank_skill/__init__.py

@@ -0,0 +1,3 @@
+"""memory-bank-skill — Universal long-term project memory for AI coding clients."""
+
+__version__ = "3.0.0"

memory_bank_skill/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point: `python -m memory_bank_skill`."""
+
+from memory_bank_skill.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

memory_bank_skill/_bundle.py

@@ -0,0 +1,48 @@
+"""Resolve paths to bundled skill files (install.sh, hooks/, adapters/, etc.).
+
+Priority order:
+1. $MB_SKILL_BUNDLE env override (for dev/testing)
+2. Installed package data via sys.prefix/share/memory-bank-skill/
+3. Development layout (running from repo checkout: ../install.sh relative to this file)
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+
+def _candidate_paths() -> list[Path]:
+    paths: list[Path] = []
+
+    override = os.environ.get("MB_SKILL_BUNDLE")
+    if override:
+        paths.append(Path(override))
+
+    # Installed via pipx / pip — shared-data goes to <prefix>/share/memory-bank-skill/
+    prefix_share = Path(sys.prefix) / "share" / "memory-bank-skill"
+    paths.append(prefix_share)
+
+    # Dev layout: repo root is parent of memory_bank_skill/
+    dev_root = Path(__file__).resolve().parent.parent
+    paths.append(dev_root)
+
+    return paths
+
+
+def find_bundle_root() -> Path:
+    """Return directory containing install.sh + skill resources, or raise."""
+    for p in _candidate_paths():
+        if (p / "install.sh").is_file():
+            return p
+    searched = "\n  ".join(str(p) for p in _candidate_paths())
+    raise FileNotFoundError(
+        f"Cannot locate memory-bank-skill bundle. Searched:\n  {searched}\n"
+        "Set MB_SKILL_BUNDLE env to point at the skill directory."
+    )
+
+
+def bundle_file(relative: str) -> Path:
+    """Get absolute path to a bundled file like 'install.sh' or 'adapters/cursor.sh'."""
+    return find_bundle_root() / relative

memory_bank_skill/cli.py

@@ -0,0 +1,272 @@
+"""memory-bank CLI — thin Python wrapper over install.sh / uninstall.sh.
+
+Subcommands:
+    install       Run global + optional cross-agent adapter install
+    uninstall     Remove global install
+    init          Bootstrap .memory-bank/ in current project (hint: use /mb init)
+    version       Print version string
+    self-update   Suggest pipx upgrade command
+    doctor        Print resolved bundle path + platform info
+
+Platform support:
+    - macOS / Linux: native bash
+    - Windows + Git for Windows: auto-detects bash.exe (C:\\Program Files\\Git\\bin\\)
+    - Windows + WSL: routes through `wsl bash` if `bash.exe` not found on PATH
+    - Windows without either: exits with install hint for Git/WSL
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from memory_bank_skill import __version__
+from memory_bank_skill._bundle import find_bundle_root
+
+PACKAGE_NAME = "memory-bank-skill"
+VALID_CLIENTS = (
+    "claude-code",
+    "cursor",
+    "windsurf",
+    "cline",
+    "kilo",
+    "opencode",
+    "pi",
+    "codex",
+)
+VALID_LANGUAGES = ("en", "ru")
+
+
+# ═══ Platform detection ═══
+def is_windows() -> bool:
+    return platform.system().lower() == "windows"
+
+
+# Common locations where Git for Windows installs bash.exe.
+# Listed in priority order (user install first, system install second).
+WINDOWS_BASH_CANDIDATES: tuple[str, ...] = (
+    r"C:\Program Files\Git\bin\bash.exe",
+    r"C:\Program Files (x86)\Git\bin\bash.exe",
+    r"C:\Users\Public\Git\bin\bash.exe",
+)
+
+
+def _env_bash_override() -> str | None:
+    """Explicit user override: MB_BASH=/path/to/bash.exe."""
+    override = os.environ.get("MB_BASH")
+    if override and Path(override).exists():
+        return override
+    return None
+
+
+def find_bash() -> str | None:
+    """Locate a usable bash executable. Returns absolute path or None."""
+    # Explicit override wins.
+    override = _env_bash_override()
+    if override:
+        return override
+
+    # POSIX: `bash` on PATH is the normal case.
+    if not is_windows():
+        found = shutil.which("bash")
+        return found
+
+    # Windows: prefer `bash.exe` on PATH (Git Bash adds its dir).
+    found = shutil.which("bash.exe") or shutil.which("bash")
+    if found and "system32" not in found.lower():
+        # Guard against WSL's C:\Windows\System32\bash.exe — that launches WSL
+        # interactively without forwarding the script path correctly in every
+        # environment. Skip it; fall through to explicit Git Bash paths first.
+        return found
+
+    # Check well-known Git for Windows install locations.
+    for candidate in WINDOWS_BASH_CANDIDATES:
+        if Path(candidate).exists():
+            return candidate
+
+    # Last resort: WSL via `wsl bash`. Only return if wsl.exe exists.
+    wsl = shutil.which("wsl.exe") or shutil.which("wsl")
+    if wsl:
+        return wsl  # run_shell() handles the `wsl bash ...` invocation form.
+
+    return None
+
+
+def windows_install_hint() -> str:
+    return (
+        "memory-bank-skill needs bash on Windows. Install one of:\n"
+        "  • Git for Windows:  winget install Git.Git   (provides bash.exe)\n"
+        "  • WSL:              wsl --install            (full Linux env)\n"
+        "\n"
+        "Then re-run the command. Override detection with:\n"
+        '  set MB_BASH="C:\\path\\to\\bash.exe"\n'
+    )
+
+
+def require_bash() -> str:
+    """Return path to bash or exit with a helpful message."""
+    bash = find_bash()
+    if bash:
+        return bash
+    if is_windows():
+        sys.stderr.write(windows_install_hint())
+    else:
+        sys.stderr.write("[memory-bank] `bash` not found on PATH\n")
+    sys.exit(2)
+
+
+# ═══ Shell invocation ═══
+def run_shell(script: str, *args: str) -> int:
+    """Execute a bundled shell script, returning its exit code."""
+    bundle = find_bundle_root()
+    script_path = bundle / script
+    if not script_path.is_file():
+        sys.stderr.write(f"[memory-bank] missing bundled script: {script_path}\n")
+        return 3
+
+    bash = require_bash()
+    bash_lower = bash.lower()
+    is_wsl_wrapper = is_windows() and (bash_lower.endswith("wsl.exe") or bash_lower.endswith("wsl"))
+
+    if is_wsl_wrapper:
+        # WSL mode: `wsl bash <script> <args>`. WSL auto-translates C:\ paths
+        # under /mnt/c/ when the script resides on the Windows filesystem.
+        cmd = [bash, "bash", str(script_path), *args]
+    else:
+        cmd = [bash, str(script_path), *args]
+
+    try:
+        result = subprocess.run(cmd, check=False)  # noqa: S603
+    except FileNotFoundError:
+        sys.stderr.write(f"[memory-bank] `{bash}` not found on PATH\n")
+        return 4
+    return result.returncode
+
+
+# ═══ Subcommand handlers ═══
+def cmd_install(args: argparse.Namespace) -> int:
+    sh_args: list[str] = []
+    if args.clients:
+        sh_args.extend(["--clients", args.clients])
+    if args.language:
+        sh_args.extend(["--language", args.language])
+    if args.project_root:
+        sh_args.extend(["--project-root", args.project_root])
+    if args.non_interactive:
+        sh_args.append("--non-interactive")
+    return run_shell("install.sh", *sh_args)
+
+
+def cmd_uninstall(_args: argparse.Namespace) -> int:
+    return run_shell("uninstall.sh")
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    # `/mb init` is handled by Claude Code command; CLI just hints
+    target = args.project_root or os.getcwd()
+    sys.stdout.write(
+        f"[memory-bank] To initialize Memory Bank for a project, run inside Claude Code:\n"
+        f"    /mb init\n\n"
+        f"  Target project: {target}\n"
+        f"  This creates .memory-bank/ with STATUS.md, checklist.md, plan.md, RESEARCH.md.\n"
+    )
+    return 0
+
+
+def cmd_version(_args: argparse.Namespace) -> int:
+    sys.stdout.write(f"memory-bank-skill {__version__}\n")
+    return 0
+
+
+def cmd_self_update(_args: argparse.Namespace) -> int:
+    sys.stdout.write(
+        f"To update memory-bank-skill:\n"
+        f"    pipx upgrade {PACKAGE_NAME}\n\n"
+        f"Or (if installed via pip): pip install --upgrade {PACKAGE_NAME}\n"
+    )
+    return 0
+
+
+def cmd_doctor(_args: argparse.Namespace) -> int:
+    sys.stdout.write(f"memory-bank-skill {__version__}\n")
+    sys.stdout.write(f"Platform: {platform.system()} {platform.release()}\n")
+    sys.stdout.write(f"Python: {sys.version.split()[0]}\n")
+    try:
+        root = find_bundle_root()
+        sys.stdout.write(f"Bundle root: {root}\n")
+        sys.stdout.write(f"install.sh: {(root / 'install.sh').is_file()}\n")
+        sys.stdout.write(f"adapters/: {(root / 'adapters').is_dir()}\n")
+    except FileNotFoundError as e:
+        sys.stdout.write(f"Bundle: NOT FOUND ({e})\n")
+        return 1
+
+    # Bash discovery: now same report on every platform.
+    bash = find_bash()
+    if bash:
+        sys.stdout.write(f"bash: {bash}\n")
+        if is_windows():
+            sys.stdout.write("  (Windows: Git Bash / WSL detected — install / uninstall work.)\n")
+    else:
+        sys.stdout.write("bash: NOT FOUND\n")
+        if is_windows():
+            sys.stdout.write(windows_install_hint())
+        return 1
+    return 0
+
+
+# ═══ Argparse ═══
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="memory-bank",
+        description="Universal long-term project memory for AI coding clients.",
+    )
+    parser.add_argument("--version", action="version", version=f"memory-bank-skill {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True, metavar="COMMAND")
+
+    p_install = sub.add_parser("install", help="Install skill globally + optional cross-agent adapters")
+    p_install.add_argument(
+        "--clients",
+        help=f"Comma-separated client list. Valid: {', '.join(VALID_CLIENTS)}. "
+             "Omit to use interactive menu when running in a TTY.",
+    )
+    p_install.add_argument(
+        "--language",
+        choices=VALID_LANGUAGES,
+        help=f"Preferred installed rules language. Valid: {', '.join(VALID_LANGUAGES)}.",
+    )
+    p_install.add_argument("--project-root", help="Target directory for cross-agent adapters (default: PWD)")
+    p_install.add_argument(
+        "--non-interactive",
+        action="store_true",
+        help="Skip interactive prompts; use defaults when --clients not specified.",
+    )
+    p_install.set_defaults(func=cmd_install)
+
+    p_uninstall = sub.add_parser("uninstall", help="Remove global skill install")
+    p_uninstall.set_defaults(func=cmd_uninstall)
+
+    p_init = sub.add_parser("init", help="Print initialization hint (use /mb init inside Claude Code)")
+    p_init.add_argument("--project-root", help="Target project directory (default: PWD)")
+    p_init.set_defaults(func=cmd_init)
+
+    p_version = sub.add_parser("version", help="Print version")
+    p_version.set_defaults(func=cmd_version)
+
+    p_update = sub.add_parser("self-update", help="Show upgrade command")
+    p_update.set_defaults(func=cmd_self_update)
+
+    p_doctor = sub.add_parser("doctor", help="Show bundle resolution + platform info")
+    p_doctor.set_defaults(func=cmd_doctor)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)

memory_bank_skill-3.0.0.data/data/share/memory-bank-skill/SKILL.md

@@ -0,0 +1,231 @@
+---
+name: memory-bank
+description: "Agent-agnostic long-term project memory through `.memory-bank/` + RULES (TDD/SOLID/Clean Architecture/FSD/Mobile) + dev-toolkit commands. Use when working in a project with a `.memory-bank/` directory or when the user explicitly asks for memory-bank workflow, code rules, or dev-toolkit commands."
+---
+
+# Memory Bank Skill
+
+Three-in-one skill for code agents:
+
+1. **Memory Bank** — long-term project memory through `.memory-bank/` (`STATUS`, `plan`, `checklist`, `RESEARCH`, `BACKLOG`, `progress`, `lessons`, `notes/`, `plans/`, `experiments/`, `reports/`, `codebase/`).
+2. **RULES** — global engineering rules: TDD, Clean Architecture (backend), FSD (frontend), Mobile (iOS/Android UDF), SOLID, Testing Trophy.
+3. **Dev toolkit** — 18 commands: `/mb`, `/commit`, `/review`, `/test`, `/plan`, `/pr`, `/adr`, `/contract`, `/security-review`, `/db-migration`, `/api-contract`, `/observability`, `/refactor`, `/doc`, `/changelog`, `/catchup`, `/start`, `/done`.
+
+Supported host model:
+- **Claude Code / OpenCode** — native command surface + global install.
+- **Cursor** — native full support: global skill alias (`~/.cursor/skills/memory-bank/`), global hooks (`~/.cursor/hooks.json`), global slash commands (`~/.cursor/commands/`), `~/.cursor/AGENTS.md` with managed section, plus a paste-ready file for Settings → Rules → User Rules. Project-level `.cursor/` adapter remains available as an add-on via `--clients cursor`.
+- **Codex** — global skill discovery + `AGENTS.md` hints + project-level `.codex/` adapter; no separate native slash-command surface.
+- **Other code agents** — via adapters, `AGENTS.md`, local hooks/configs, or direct CLI/script usage.
+
+---
+
+## Quick start
+
+```bash
+# Initialization (stack auto-detect + CLAUDE.md generation)
+/mb init                 # same as /mb init --full
+/mb init --minimal       # only the .memory-bank/ structure
+
+# Session flow
+/mb start                # load context
+# ... work, checklist.md updates as tasks complete ...
+/mb verify               # verify plan alignment (if there was a plan)
+/mb done                 # actualize + note + progress
+```
+
+If the host does not support native slash commands, use:
+- `commands/mb.md` as the workflow entrypoint;
+- the `memory-bank ...` CLI for install/init/doctor flows;
+- bundled scripts and agent prompts from this skill bundle.
+
+---
+
+## Workspace resolution
+
+Memory Bank supports external storage through `.claude-workspace`:
+
+- If the project root contains `.claude-workspace` with `storage: external` and `project_id: <id>` → `mb_path = ~/.claude/workspaces/<id>/.memory-bank`
+- Otherwise → `mb_path = ./.memory-bank` (default)
+
+When invoking MB Manager or scripts, always pass the resolved `mb_path`.
+
+---
+
+## Tools — shell scripts
+
+All scripts live in `scripts/` next to this `SKILL.md`. In global installs, the bundle is typically available through host aliases:
+- Claude Code: `~/.claude/skills/memory-bank/`
+- Codex: `~/.codex/skills/memory-bank/`
+- Cursor: `~/.cursor/skills/memory-bank/`
+
+Scripts work with `.memory-bank/` in the current directory or through the `mb_path` argument.
+
+| Script | Purpose |
+|--------|---------|
+| `mb-context.sh [--deep]` | Build context from core files (`STATUS` + `plan` + `checklist` + `RESEARCH` + codebase summary). `--deep` shows full codebase docs |
+| `mb-search.sh <q> [--tag t]` | Search. `--tag` filters via `index.json` |
+| `mb-note.sh <topic>` | Create `notes/YYYY-MM-DD_HH-MM_<topic>.md`. Collision-safe (`_2` / `_3`) |
+| `mb-plan.sh <type> <topic>` | Create `plans/YYYY-MM-DD_<type>_<topic>.md` with `<!-- mb-stage:N -->` markers |
+| `mb-plan-sync.sh <plan>` | Synchronize plan ↔ checklist + `plan.md` (idempotent) |
+| `mb-plan-done.sh <plan>` | Close a plan: `⬜→✅` + move to `plans/done/` |
+| `mb-metrics.sh [--run]` | Language-agnostic metrics (12 stacks). `--run` captures `test_status=pass|fail` |
+| `mb-index.sh` | Registry of all entries (core + notes/plans/experiments/reports) |
+| `mb-index-json.py` | Build `index.json` (frontmatter notes + lessons headings). Atomic |
+| `mb-upgrade.sh [--check|--force]` | Self-update the skill from GitHub |
+| `_lib.sh` | Shared helpers sourced by other scripts |
+
+---
+
+## Agents — subagents (sonnet)
+
+| Agent | When to invoke | Prompt |
+|-------|----------------|--------|
+| `mb-manager` | `/mb context`, `search`, `note`, `tasks`, `done`, `update`, PreCompact hook | `agents/mb-manager.md` |
+| `mb-doctor` | `/mb doctor` — memory-bank inconsistencies (use `mb-plan-sync.sh` first, only edit for semantic drift) | `agents/mb-doctor.md` |
+| `mb-codebase-mapper` | `/mb map [focus]` — scan the codebase → `.memory-bank/codebase/{STACK,ARCHITECTURE,CONVENTIONS,CONCERNS}.md` | `agents/mb-codebase-mapper.md` |
+| `plan-verifier` | `/mb verify` — required before `/mb done` when work followed a plan | `agents/plan-verifier.md` |
+
+Do **NOT** delegate plan creation, architectural decisions, or ML-result evaluation to a subagent — that is main-agent work.
+
+### Invocation format
+
+```
+Agent(
+  subagent_type="general-purpose",
+  model="sonnet",
+  description="<description>",
+  prompt="<contents of agents/<agent>.md>\n\naction: <action>\n\n<context>"
+)
+```
+
+---
+
+## Host-specific notes
+
+### Claude Code and native memory
+
+Claude Code has built-in `auto memory` (user-level cross-project memory in `~/.claude/projects/.../memory/`). This skill does **not replace** it — the two complement each other:
+
+| Aspect | `.memory-bank/` | Native `auto memory` |
+|--------|------------------|----------------------|
+| Scope | Project | User, cross-project |
+| Stores | Status, plans, checklists, research, ADRs, lessons | Preferences, role, feedback |
+| Owner | Team (via git) | Individual user |
+
+Rule of thumb: if it helps a teammate pick up the project tomorrow, store it in `.memory-bank/`. If it helps you in another project, store it in native memory. They can coexist without conflict.
+
+### Codex
+
+For Codex, this skill is positioned as a global skill bundle plus a guidance layer:
+- discovery goes through `~/.codex/skills/memory-bank/`
+- global entrypoint/guidance goes through `~/.codex/AGENTS.md`
+- hook/config integration remains primarily project-level through `.codex/`
+
+Codex therefore uses the same Memory Bank workflow, but it does not need to expose the same native command surface as Claude Code/OpenCode.
+
+### Cursor
+
+Cursor is a first-class global target. `install.sh` writes five artifacts to `~/.cursor/`:
+
+| Artifact | Purpose |
+|----------|---------|
+| `~/.cursor/skills/memory-bank/` | Personal skill alias — Cursor auto-discovers it by description |
+| `~/.cursor/hooks.json` + `~/.cursor/hooks/*.sh` | Global hooks: `sessionEnd` (autosave), `preCompact` (reminder), `beforeShellExecution` (block-dangerous). Each entry tagged `_mb_owned: true` so user hooks are preserved |
+| `~/.cursor/commands/*.md` | User-level slash commands mirrored from the skill `commands/` directory |
+| `~/.cursor/AGENTS.md` | Marker section `memory-bank-cursor:start/end` — entrypoint for future Cursor versions that read global `AGENTS.md` |
+| `~/.cursor/memory-bank-user-rules.md` | Paste-ready rules bundle for **Settings → Rules → User Rules** (Cursor exposes no file API for global User Rules, so this is a one-time manual step) |
+
+Cursor User Rules paste flow:
+
+```bash
+# macOS
+pbcopy < ~/.cursor/memory-bank-user-rules.md
+# Linux
+xclip -selection clipboard < ~/.cursor/memory-bank-user-rules.md
+```
+
+The project-level adapter (`.cursor/rules/memory-bank.mdc` + `.cursor/hooks.json`) remains available and is installed only when the user passes `--clients cursor`. Global and project-level installs coexist — Cursor merges hooks from both.
+
+---
+
+## Private content — `<private>...</private>` (since v2.1)
+
+Markdown syntax for excluding sensitive information (client data, API keys, partner names) from indexing and search:
+
+```markdown
+---
+type: note
+tags: [auth, partner-x]
+importance: high
+---
+
+Discussed with client <private>Jane Doe, +1-555-***</private>.
+Integration with <private>api_key=sk-abc123...</private> is scheduled for Tuesday.
+```
+
+**Protection model:**
+- Content inside `<private>...</private>` does **not** go into `index.json` (neither `summary` nor `tags`)
+- `mb-search` output redacts it as `[REDACTED]` (inline) or `[REDACTED match in private block]` (multi-line)
+- The entry gets a `has_private: true` flag for downstream filtering
+- An unclosed `<private>` without `</private>` makes the rest of the file private (fail-safe)
+- `hooks/file-change-log.sh` warns when committing a file containing `<private>` blocks (reminder to review git exposure)
+
+**Double confirmation for reveal:**
+```bash
+# Rejected without env:
+mb-search --show-private <query>
+# [error] --show-private requires MB_SHOW_PRIVATE=1
+
+# Only with explicit opt-in:
+MB_SHOW_PRIVATE=1 mb-search --show-private <query>
+```
+
+**Important:** `<private>` protects against leakage through `index.json` / `mb-search`, but it does **not** filter `git diff`. For full protection, consider `.gitattributes` filters or git hooks.
+
+---
+
+## Auto-capture (since v2.1)
+
+The SessionEnd hook automatically appends a placeholder entry to `progress.md` when a session ends without an explicit `/mb done`. Work is not lost even if manual actualization was skipped.
+
+**Modes (`MB_AUTO_CAPTURE` env):**
+- `auto` (default) — hook writes an entry on session end
+- `strict` — hook skips but prints a warning to stderr (for flows where manual actualization is required)
+- `off` — full noop
+
+**How it works:**
+- After successful `/mb done`, the command writes `.memory-bank/.session-lock` → the hook sees the fresh lock (<1h) and skips auto-capture (manual actualization already happened)
+- Without a lock, the hook adds a short note to `progress.md`. Full details can be reconstructed by `/mb start` in the next session (MB Manager can read the JSONL transcript)
+- Concurrency-safe through a short `.auto-lock` (30 seconds) — prevents duplicates on parallel invocations
+- Idempotent by `session_id` — same session + same day = one entry
+
+**Opt-out:** `export MB_AUTO_CAPTURE=off` in `~/.zshrc` or disable the hook via `/mb upgrade` once that flag is available.
+
+---
+
+## Weekly compact reminder (since v2.2.1)
+
+The SessionEnd hook `hooks/mb-compact-reminder.sh` reminds the user to run `/mb compact` once a week — **only if the user has explicitly run `/mb compact --apply` at least once** (which creates `.memory-bank/.last-compact`). It is opt-in by design, so new installs stay silent.
+
+**Logic:**
+- `.last-compact` missing → silent (user not subscribed)
+- `.last-compact` < 7 days → silent
+- `.last-compact` ≥ 7 days + `mb-compact.sh --dry-run` shows `candidates > 0` → reminder to stderr with a `/mb compact` hint
+- `.last-compact` ≥ 7 days + `candidates=0` → silent (nothing to compact)
+
+**Opt-out:** `export MB_COMPACT_REMIND=off`. Read-only — it never changes files.
+
+---
+
+## References
+
+- Metadata protocol + `index.json` + 8 key rules: `references/metadata.md`
+- Planning + Plan Verifier workflow: `references/planning-and-verification.md`
+- Templates: `references/templates.md`
+- Structure: `references/structure.md`
+- Workflow: `references/workflow.md`
+- CHANGELOG: `CHANGELOG.md`
+- Migration v1→v2: `docs/MIGRATION-v1-v2.md`
+- Primary entrypoint:
+  - `/mb` — if the host supports native commands
+  - `commands/mb.md` / `memory-bank` CLI — if native command surface is unavailable

memory_bank_skill-3.0.0.data/data/share/memory-bank-skill/VERSION

@@ -0,0 +1 @@
+3.0.0