@shahmilsaari/memory-core 0.1.3 → 0.1.5

package/README.md

@@ -1,75 +1,46 @@
-# @shahmilsaari/memory-core
+# memory-core
 
-Universal AI memory for any project. Install once, and every AI coding agent — Copilot, Cursor, Claude Code, Windsurf, Cline, and 13 more — automatically follows your architecture rules, past decisions, and best practices. Backed by PostgreSQL + pgvector and fully local AI via Ollama. No OpenAI key required.
+**Every AI coding agent in your project, following your rules. Automatically.**
+
+You decide the architecture. memory-core remembers it. Every AI tool — Copilot, Cursor, Claude Code, Windsurf, and 10 more — reads those rules before writing a single line of code.
 
 ```bash
 npx @shahmilsaari/memory-core init
 ```
 
----
-
-## How it works
-
-```
-memory-core init
-      │
-      ├── You pick: Backend / Frontend / Fullstack
-      ├── You pick: Architecture (Clean, MVC, React, Vue, …)
-      │
-      ▼
-PostgreSQL + pgvector
-192 predefined rules — each with a WHY
-+ your own saved decisions
-      │
-      ▼
-18 AI agent config files generated
-      │
-      ▼
-Every agent reads its file → follows your rules
-
-git commit → pre-commit hook → Ollama checks diff
-→ violations blocked with Rule + Why + Fix
-```
+No OpenAI key. No cloud. Fully local.
 
 ---
 
-## Supported agents
+## What does it actually do?
 
-| Agent | File generated |
-|---|---|
-| Claude Code | `CLAUDE.md` |
-| GitHub Copilot | `.github/copilot-instructions.md` |
-| Cursor | `.cursorrules` + `.cursor/rules/memory-core.mdc` |
-| Windsurf | `.windsurfrules` |
-| Cline | `.clinerules` |
-| Roo Code | `.roo/rules/memory-core.md` |
-| Aider | `.aider.conf.yml` |
-| Continue.dev | `.continue/config.json` |
-| Devin | `DEVIN.md` |
-| Amazon Q | `.amazonq/dev/guidelines.md` |
-| Gemini Code Assist | `.gemini/styleguide.md` |
-| Zed AI | `.zed/settings.json` |
-| JetBrains AI | `.idea/ai-instructions.md` |
-| OpenHands / AGENTS | `AGENTS.md` |
+Without memory-core, every AI agent starts fresh. It doesn't know you're using Clean Architecture. It doesn't know controllers shouldn't call the database. It doesn't know why you made that decision six months ago.
+
+With memory-core:
 
-Plus: `AI_RULES.md`, `ARCHITECTURE.md`, `PROJECT_MEMORY.md`
+1. You run `init` once and answer a few questions about your project
+2. memory-core generates config files for every AI agent you use
+3. Those agents read the files and follow your rules — automatically
+4. When you commit code, a hook catches violations before they land in the repo
+5. Watch mode catches violations as you type, not just at commit time
 
 ---
 
-## Prerequisites
+## Before you start
 
-| Requirement | Purpose |
-|---|---|
-| PostgreSQL 14+ | Memory storage |
-| pgvector | Semantic similarity search |
-| Ollama + `nomic-embed-text` | Free local embeddings (no API key) |
-| Ollama + `llama3.2` | Pre-commit rule checking |
+You need three things installed:
+
+| What | Why | Install |
+|---|---|---|
+| PostgreSQL 14+ | Stores your rules and decisions | See below |
+| pgvector | Makes search smart (finds similar rules, not just exact matches) | See below |
+| Ollama | Runs AI locally — no API key needed | See below |
 
 ---
 
-## Setup
+## Install
 
-### 1. PostgreSQL
+### PostgreSQL
 
 **macOS**
 ```bash
@@ -83,13 +54,20 @@ sudo apt install postgresql postgresql-contrib
 sudo systemctl start postgresql
 ```
 
-**Windows** — download from [postgresql.org](https://www.postgresql.org/download/windows/)
+**Windows** — [download from postgresql.org](https://www.postgresql.org/download/windows/)
 
 ---
 
-### 2. pgvector
+### pgvector
 
-**macOS with PostgreSQL@16** (brew pgvector only targets pg17+, build from source):
+pgvector adds AI-powered search to PostgreSQL.
+
+**macOS + PostgreSQL 17+** (easiest)
+```bash
+brew install pgvector
+```
+
+**macOS + PostgreSQL 16** (brew's pgvector targets 17+, so build from source)
 ```bash
 xcode-select --install
 git clone --branch v0.8.0 https://github.com/pgvector/pgvector.git /tmp/pgvector
@@ -98,24 +76,21 @@ make PG_CONFIG=/opt/homebrew/opt/postgresql@16/bin/pg_config
 make install PG_CONFIG=/opt/homebrew/opt/postgresql@16/bin/pg_config
 ```
 
-**macOS with PostgreSQL@17+**
-```bash
-brew install pgvector
-```
-
 **Linux**
 ```bash
 sudo apt install postgresql-16-pgvector   # replace 16 with your version
 ```
 
-Verify:
+Check it worked:
 ```bash
 psql -U $(whoami) -c "SELECT * FROM pg_available_extensions WHERE name = 'vector';"
 ```
 
 ---
 
-### 3. Ollama
+### Ollama
+
+Ollama runs AI models on your machine. Two models are needed — one for search, one for code checking.
 
 **macOS**
 ```bash
@@ -129,28 +104,24 @@ curl -fsSL https://ollama.com/install.sh | sh
 ollama serve &
 ```
 
-**Windows** — download from [ollama.com](https://ollama.com/download)
+**Windows** — [download from ollama.com](https://ollama.com/download)
 
-Pull the required models:
+Then pull the two models:
 ```bash
-ollama pull nomic-embed-text   # embeddings — used by remember/search/sync
-ollama pull llama3.2           # code analysis — used by pre-commit hook
+ollama pull nomic-embed-text   # used for search
+ollama pull llama3.2           # used to check your code
 ```
 
 ---
 
-### 4. Create the database
+### Create the database
 
 ```bash
 createdb memory_core
-```
-
-Then run the schema (get `setup.sql` from the repo or copy below):
-```bash
 psql -U $(whoami) -d memory_core -f setup.sql
 ```
 
-`setup.sql` contents:
+`setup.sql`:
 ```sql
 CREATE EXTENSION IF NOT EXISTS vector;
 
@@ -169,38 +140,31 @@ CREATE TABLE IF NOT EXISTS memories (
 );
 
 CREATE INDEX IF NOT EXISTS memories_embedding_idx
-  ON memories USING ivfflat (embedding vector_cosine_ops)
-  WITH (lists = 100);
-
+  ON memories USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
 CREATE INDEX IF NOT EXISTS memories_architecture_idx ON memories (architecture);
 CREATE INDEX IF NOT EXISTS memories_scope_idx ON memories (scope);
 ```
 
 ---
 
-### 5. Configure environment
-
-Create `.env` in the project where you run memory-core (or `.memory-core.env` per project):
-
-```env
-DATABASE_URL=postgresql://YOUR_USERNAME@localhost:5432/memory_core
-OLLAMA_URL=http://localhost:11434
-OLLAMA_MODEL=nomic-embed-text
-OLLAMA_CHAT_MODEL=llama3.2
-```
-
-Find your username: `whoami`
-
----
+## Quick start
 
-### 6. Seed the database
+```bash
+# 1. Go to your project
+cd my-api
 
-Load 192 predefined best-practice rules (each with a reason explaining why it exists):
+# 2. Initialize — answers a few questions, generates all config files
+npx @shahmilsaari/memory-core init
 
-```bash
+# 3. Load 192 predefined best-practice rules
 npx @shahmilsaari/memory-core seed
+
+# 4. Install the pre-commit hook (optional but recommended)
+npx @shahmilsaari/memory-core hook install
 ```
 
+That's it. Every AI agent in your project now has your rules.
+
 ---
 
 ## Commands
@@ -208,107 +172,108 @@ npx @shahmilsaari/memory-core seed
 ### `init` — Set up a project
 
 ```bash
-cd your-project
 npx @shahmilsaari/memory-core init
 ```
 
-Interactive prompts:
-```
-Project name?         → my-api
-Project type?         → Backend / Frontend / Fullstack
-Backend architecture? → Clean Architecture
-Frontend framework?   → (skipped for backend-only)
-Language?             → TypeScript
-Install caveman?      → no
-```
+Asks you:
+- Project name
+- Project type (Backend / Frontend / Fullstack)
+- Architecture (Clean Architecture, MVC, React, Vue, etc.)
+- Language
+- Whether to enable caveman mode (optional token saver)
 
-Generates all 18 agent config files and saves `.memory-core.json`.
-
----
-
-### `sync` — Regenerate all agent files
-
-```bash
-npx @shahmilsaari/memory-core sync
-```
-
-Re-pulls memories from the DB and rewrites all 18 files. Run after `remember` or `seed`.
+Generates config files for every supported AI agent and saves your choices to `.memory-core.json`.
 
 ---
 
 ### `remember` — Save a decision
 
+Made a decision your team should never forget? Save it.
+
 ```bash
 npx @shahmilsaari/memory-core remember "Controllers must never call the database directly"
 ```
 
-Prompts: _"Why does this rule exist?"_ — the reason is stored and shown to agents and developers when a violation is caught.
+It will ask you *why* — that reason gets stored alongside the rule and shown to AI agents and developers when a violation is caught.
 
-With flags:
+With flags (skip the prompts):
 ```bash
 npx @shahmilsaari/memory-core remember "Use DTOs for all API responses" \
   --type rule \
   --scope global \
-  --reason "Raw DB entities leak internal schema and expose sensitive fields to clients" \
-  --tags "api,dto,response"
+  --reason "Raw DB entities expose internal schema and sensitive fields" \
+  --tags "api,dto"
 ```
 
-| Flag | Values | Default |
+| Flag | Options | Default |
 |---|---|---|
 | `--type` | `decision` `rule` `pattern` `note` | `decision` |
 | `--scope` | `global` `project` | `project` |
-| `--reason` | free text | prompted interactively |
+| `--reason` | any text | asked interactively |
 | `--tags` | comma-separated | none |
 
 ---
 
-### `search` — Semantic search
+### `sync` — Refresh all agent files
+
+After saving new memories, regenerate every agent file to include them.
+
+```bash
+npx @shahmilsaari/memory-core sync
+```
+
+---
+
+### `search` — Find a rule or decision
 
 ```bash
 npx @shahmilsaari/memory-core search "error handling"
 npx @shahmilsaari/memory-core search "auth strategy" --limit 10
 ```
 
+Uses AI search — finds related rules even if you don't use the exact words.
+
 ---
 
 ### `seed` — Load predefined rules
 
+192 best-practice rules across all supported architectures, each with a plain-English reason explaining why the rule exists.
+
 ```bash
-npx @shahmilsaari/memory-core seed
-npx @shahmilsaari/memory-core seed --arch clean-architecture   # one architecture only
-npx @shahmilsaari/memory-core seed --force                     # re-seed existing entries
+npx @shahmilsaari/memory-core seed                              # all architectures
+npx @shahmilsaari/memory-core seed --arch clean-architecture   # one only
+npx @shahmilsaari/memory-core seed --force                     # re-seed existing
 ```
 
-192 rules across all architectures. Every rule includes a `reason` explaining why it exists.
-
 ---
 
-### `hook install` — Pre-commit enforcement
+### `hook install` — Block bad commits
 
 ```bash
 npx @shahmilsaari/memory-core hook install
 ```
 
-Installs a git pre-commit hook. Every `git commit` automatically checks staged source files against your architecture rules using Ollama (llama3.2). Violations are blocked with full context:
+Installs a git pre-commit hook. Every time you run `git commit`, your staged files are checked against your architecture rules before the commit goes through.
+
+When a violation is found, the commit is blocked and you see exactly what's wrong and how to fix it:
 
 ```
   ✗ 2 rule violations found — commit blocked
 
   [1] src/controllers/user.ts:32
       Rule:   Thin controllers — business logic belongs in services
-      Why:    Logic in controllers cannot be reused from CLI, queues, or other
-              entry points — it gets siloed and duplicated across handlers
+      Why:    Logic in controllers cannot be reused from other entry points
+              — it gets siloed and duplicated across handlers
       Issue:  Password validation logic inside route handler
       Fix:    Move to UserService.validateCredentials()
 
   [2] src/domain/user.entity.ts:5
       Rule:   Domain has zero external imports
-      Why:    Framework imports in the domain layer tie business logic to
-              infrastructure — you can't swap the DB or test without spinning up the stack
+      Why:    Framework imports tie business logic to infrastructure
       Issue:  Imports 'typeorm' directly
-      Fix:    Define IUserRepository interface in domain, implement in infrastructure/
+      Fix:    Define IUserRepository interface in domain/
 
-  To bypass (not recommended): git commit --no-verify
+  To bypass: git commit --no-verify
   To save as memory: memory-core remember "<lesson>"
 ```
 
@@ -318,13 +283,13 @@ npx @shahmilsaari/memory-core hook uninstall   # remove the hook
 
 ---
 
-### `watch` — Real-time rule checking
+### `watch` — Catch violations as you type
 
 ```bash
 npx @shahmilsaari/memory-core watch
 ```
 
-Runs in your terminal and checks every source file as you save it. Violations print immediately — no commit needed.
+Runs in the background and checks each file the moment you save it. You see violations immediately — before you even think about committing.
 
 ```
   archmind watch — real-time rule enforcement
@@ -340,44 +305,41 @@ Runs in your terminal and checks every source file as you save it. Violations pr
 
   [1] src/controllers/user.ts:34
       Rule:   Thin controllers — business logic belongs in services
-      Why:    Logic in controllers cannot be reused from CLI, queues, or other
-              entry points — it gets siloed and duplicated across handlers
+      Why:    Logic in controllers cannot be reused from other entry points
       Issue:  Password hashing inside the route handler
       Fix:    Move to UserService.hashPassword()
-
-  Fix violations or run: memory-core remember "<lesson>"
 ```
 
 Options:
 ```bash
-npx @shahmilsaari/memory-core watch --path src/      # watch a specific directory
-npx @shahmilsaari/memory-core watch --verbose        # show diff size and model details
+npx @shahmilsaari/memory-core watch --path src/   # watch a specific folder only
+npx @shahmilsaari/memory-core watch --verbose     # show extra details
 ```
 
-Ignores: `node_modules`, `dist`, `build`, `.git`, config files — only checks source code.
+Only checks source files — ignores `node_modules`, `dist`, config files, JSON, etc.
 
 ---
 
-### `check` — Manual rule check
+### `check` — Manual check (for CI)
 
 ```bash
 npx @shahmilsaari/memory-core check --staged           # check staged files
-npx @shahmilsaari/memory-core check --staged --verbose # show model + diff details
+npx @shahmilsaari/memory-core check --staged --verbose # with extra detail
 ```
 
-Same as the pre-commit hook — useful in CI/CD pipelines.
+Same as the pre-commit hook. Use this in CI/CD pipelines.
 
 ---
 
-### `global` — Sync to all agents globally
-
-Writes your rules to the global config of every installed agent — so they follow your rules in every project without running `init`:
+### `global` — Apply rules to every project
 
 ```bash
 npx @shahmilsaari/memory-core global
 ```
 
-| Agent | Global file |
+Writes your rules to the global config of each AI agent — so they follow your rules in every project on your machine, not just the current one.
+
+| Agent | Where it writes |
 |---|---|
 | Claude Code | `~/.claude/CLAUDE.md` |
 | GitHub Copilot | VS Code `settings.json` |
@@ -390,63 +352,89 @@ npx @shahmilsaari/memory-core global
 
 ---
 
+## Supported agents
+
+| Agent | File generated |
+|---|---|
+| Claude Code | `CLAUDE.md` |
+| GitHub Copilot | `.github/copilot-instructions.md` |
+| Cursor | `.cursorrules` + `.cursor/rules/memory-core.mdc` |
+| Windsurf | `.windsurfrules` |
+| Cline | `.clinerules` |
+| Roo Code | `.roo/rules/memory-core.md` |
+| Aider | `.aider.conf.yml` |
+| Continue.dev | `.continue/config.json` |
+| Devin | `DEVIN.md` |
+| Amazon Q | `.amazonq/dev/guidelines.md` |
+| Gemini Code Assist | `.gemini/styleguide.md` |
+| Zed AI | `.zed/settings.json` |
+| JetBrains AI | `.idea/ai-instructions.md` |
+| OpenHands | `AGENTS.md` |
+
+Plus shared files: `AI_RULES.md`, `ARCHITECTURE.md`, `PROJECT_MEMORY.md`
+
+---
+
 ## Architecture profiles
 
-### Backend
-| Profile | Best for |
+Pick the one that matches how your project is structured.
+
+**Backend**
+| Profile | Use when… |
 |---|---|
-| **Clean Architecture** | Domain-driven APIs, strict layer separation |
-| **Modular Monolith** | Feature modules that could become microservices |
-| **MVC** | Standard web apps, controllers + services |
-| **Hexagonal** | Port/adapter isolation, highly testable cores |
-| **Next.js** | Next.js 13+ fullstack (server components + actions) |
-| **Laravel** | Laravel APIs with service-repository pattern |
-
-### Frontend
-| Profile | Best for |
+| Clean Architecture | You want strict separation between domain, application, and infrastructure |
+| Modular Monolith | You're building feature modules that might become microservices later |
+| MVC | Standard web app with controllers and services |
+| Hexagonal | You want ports and adapters for maximum testability |
+| Next.js | Next.js 13+ with server components and server actions |
+| Laravel | Laravel with service-repository pattern |
+
+**Frontend**
+| Profile | Use when… |
 |---|---|
-| **React** | Functional components, hooks, React Query, Zustand |
-| **Vue 3** | Composition API, Pinia, composables |
-| **Angular** | Standalone components, signals, OnPush |
-| **Svelte** | Svelte 5 runes, SvelteKit load functions |
-| **Nuxt 3** | Fullstack Vue with SSR, server routes |
-| **React Native** | Mobile apps, FlatList, secure storage |
+| React | Functional components, hooks, React Query, Zustand |
+| Vue 3 | Composition API, Pinia, composables |
+| Angular | Standalone components, signals, OnPush strategy |
+| Svelte | Svelte 5 runes, SvelteKit load functions |
+| Nuxt 3 | Fullstack Vue with SSR |
+| React Native | Mobile apps |
 
-Fullstack projects get dual sections — one for backend, one for frontend — in every generated agent file.
+Fullstack projects get both sections in every generated file.
 
 ---
 
-## Caveman token saver (optional)
+## Caveman mode (optional)
 
-Compresses AI responses 65–75% by stripping filler words. Enabled optionally during `init`. Injected into every agent file automatically.
+Cuts AI response length by 65–75% by removing filler words. Opt in during `init`.
 
-| Level | Style |
+| Level | What it does |
 |---|---|
-| `lite` | Professional terseness |
-| `full` | Caveman mode |
-| `ultra` | Telegraphic, minimum words |
+| `lite` | Professional and concise |
+| `full` | Caveman-style short answers |
+| `ultra` | Absolute minimum words |
 
 ---
 
-## Typical workflow
+## Day-to-day workflow
 
 ```bash
-# New project
+# Starting a new project
 cd my-api
 npx @shahmilsaari/memory-core init
+npx @shahmilsaari/memory-core seed
 npx @shahmilsaari/memory-core hook install
 
-# Save a decision mid-project
-npx @shahmilsaari/memory-core remember "All auth goes through middleware, never duplicated in controllers" \
+# Made an architectural decision? Save it.
+npx @shahmilsaari/memory-core remember "All auth goes through middleware, never in controllers" \
   --type decision --scope global
 
-# Sync agent files after new decisions
+# Refresh agent files after saving new memories
 npx @shahmilsaari/memory-core sync
 
-# Search before making an architectural decision
+# Not sure how something was decided? Search.
 npx @shahmilsaari/memory-core search "caching strategy"
 
-# Try to commit code that breaks rules → hook blocks it with explanation
+# Commit code → hook checks it automatically
 git commit -m "add user endpoint"
 ```
 
@@ -454,49 +442,51 @@ git commit -m "add user endpoint"
 
 ## Environment variables
 
-| Variable | Required | Default | Description |
+memory-core creates `.memory-core.env` automatically during `init`. You can also set these manually:
+
+| Variable | Required | Default | What it does |
 |---|---|---|---|
 | `DATABASE_URL` | Yes | — | PostgreSQL connection string |
-| `OLLAMA_URL` | No | `http://localhost:11434` | Ollama server URL |
-| `OLLAMA_MODEL` | No | `nomic-embed-text` | Embedding model |
-| `OLLAMA_CHAT_MODEL` | No | `llama3.2` | Chat model for pre-commit checks |
+| `OLLAMA_URL` | No | `http://localhost:11434` | Where Ollama is running |
+| `OLLAMA_MODEL` | No | `nomic-embed-text` | Model used for search |
+| `OLLAMA_CHAT_MODEL` | No | `llama3.2` | Model used for code checking |
 
 ---
 
 ## Troubleshooting
 
 **`extension "vector" is not available`**
-pgvector not installed for your PostgreSQL version. See [pgvector setup](#2-pgvector-setup).
+pgvector isn't installed for your PostgreSQL version. Follow the [pgvector install steps](#pgvector) above.
 
 **`Ollama not running — skipping rule check`**
 Start Ollama: `brew services start ollama` (macOS) or `ollama serve` (Linux).
 
 **`Chat model "llama3.2" not found`**
-Pull the model: `ollama pull llama3.2`. Or set `OLLAMA_CHAT_MODEL=mistral` in `.env`.
+Run `ollama pull llama3.2`. Or switch to another model: add `OLLAMA_CHAT_MODEL=mistral` to `.memory-core.env`.
 
 **`DATABASE_URL is not set`**
-Create `.env` in your project root. See [Configure environment](#5-configure-environment).
+Run `npx @shahmilsaari/memory-core init` — it will create the `.memory-core.env` file for you.
 
 **`createdb: role does not exist`**
 ```bash
 createuser -s $(whoami)
 ```
 
-**Pre-commit hook flagging config/JSON files**
-The hook only checks source files (`.ts .tsx .js .jsx .py .php .rb .go .java .cs .swift .kt .rs .vue .svelte`). Config and env files are automatically skipped.
+**Hook is flagging JSON or config files**
+It won't — the hook only checks source code files: `.ts .tsx .js .jsx .py .php .rb .go .java .cs .swift .kt .rs .vue .svelte`. Everything else is skipped automatically.
 
 ---
 
 ## Roadmap
 
-| Feature | Description |
+| | Feature |
 |---|---|
-| CI/CD check | GitHub Actions workflow — fails PRs that violate rules |
-| ✓ Watch mode | `memory-core watch` — checks files on save in real-time |
-| Violation memory | Auto-save caught violations as "never do X, do Y" memories |
-| Rule analytics | Track which rules break most, which files are worst offenders |
-| Team sync | `memory-core push/pull` — shared memory pool across the whole team |
-| Memory review | `memory-core approve` — team sign-off before rules propagate |
+| ✓ | Watch mode — real-time violation alerts on save |
+| | CI/CD — fail PRs that violate your rules |
+| | Violation memory — auto-save what went wrong as a new rule |
+| | Rule analytics — see which rules get broken most |
+| | Team sync — share memory across your whole team |
+| | Memory review — approve rules before they propagate |
 
 ---
 

package/dist/cli.js

@@ -789,14 +789,6 @@ import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { join as join5, relative } from "path";
 import chalk2 from "chalk";
 var SOURCE_EXTENSIONS = /\.(ts|tsx|js|jsx|py|php|rb|go|java|cs|swift|kt|rs|vue|svelte)$/;
-var IGNORE_PATTERNS = [
-  /node_modules/,
-  /\.git/,
-  /dist\//,
-  /build\//,
-  /coverage\//,
-  /\.memory-core/
-];
 var reasonMap2 = new Map(
   seeds.filter((s) => s.reason).map((s) => [s.content, s.reason])
 );
@@ -966,17 +958,22 @@ function startWatch(options = {}) {
   const pending = /* @__PURE__ */ new Map();
   let ollamaWarned = false;
   const watcher = watch(watchPath, {
-    ignored: (filePath) => {
-      if (IGNORE_PATTERNS.some((p) => p.test(filePath))) return true;
-      const isFile = !filePath.endsWith("/");
-      if (isFile && !SOURCE_EXTENSIONS.test(filePath)) return true;
-      return false;
-    },
+    ignored: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/coverage/**",
+      "**/.memory-core*"
+    ],
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 }
   });
+  const keepAlive = setInterval(() => {
+  }, 1 << 30);
   const handle = (filePath) => {
+    if (!SOURCE_EXTENSIONS.test(filePath)) return;
     if (pending.has(filePath)) clearTimeout(pending.get(filePath));
     const timer = setTimeout(async () => {
       pending.delete(filePath);
@@ -1005,6 +1002,7 @@ function startWatch(options = {}) {
   });
   process.on("SIGINT", () => {
     console.log(chalk2.dim("\n\n  archmind watch stopped.\n"));
+    clearInterval(keepAlive);
     watcher.close();
     process.exit(0);
   });
@@ -1039,6 +1037,7 @@ function printBanner(projectName, agentCount) {
   ];
   lines.forEach((l) => console.log(l));
 }
+var { version } = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf-8"));
 var CONFIG_FILE = ".memory-core.json";
 function readProjectConfig() {
   const path = join6(process.cwd(), CONFIG_FILE);
@@ -1053,7 +1052,7 @@ function writeProjectConfig(config2) {
   writeFileSync3(join6(process.cwd(), CONFIG_FILE), JSON.stringify(config2, null, 2));
 }
 var program = new Command();
-program.name("memory-core").description("Universal AI memory core \u2014 generate AI context files for all coding agents").version("0.1.0");
+program.name("memory-core").description("Universal AI memory core \u2014 generate AI context files for all coding agents").version(version);
 program.command("init").description("Initialize memory-core in the current project").action(async () => {
   console.log(chalk3.bold.cyan("\n  memory-core init\n"));
   const detected = detectProject();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shahmilsaari/memory-core",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Universal AI memory core — generate AI context files from architecture profiles with RAG support",
   "type": "module",
   "bin": {