@prih/mcp-graph-memory 1.0.3

package/dist/lib/search/tasks.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchTasks = searchTasks;
+const embedder_1 = require("../../lib/embedder");
+const bm25_1 = require("../../lib/search/bm25");
+/**
+ * Semantic search over the task graph.
+ *
+ * 1. Score every node by cosine similarity to the query embedding.
+ * 2. Filter seeds below `minScore`, take top `topK`.
+ * 3. BFS expansion via relation edges up to `bfsDepth` hops with score decay.
+ * 4. De-duplicate, re-filter, sort, cap at `maxResults`.
+ */
+function searchTasks(graph, queryEmbedding, options = {}) {
+    const { topK = 5, bfsDepth = 1, maxResults = 20, minScore = 0.5, bfsDecay = 0.8, queryText, bm25Index, searchMode = 'hybrid', rrfK = 60 } = options;
+    const useVector = searchMode !== 'keyword';
+    const useBm25 = searchMode !== 'vector' && !!queryText && !!bm25Index;
+    // --- 1. Score all nodes (skip proxy nodes) ---
+    const scored = [];
+    if (useVector) {
+        graph.forEachNode((id, attrs) => {
+            if (attrs.proxyFor)
+                return;
+            if (attrs.embedding.length === 0)
+                return;
+            scored.push({ id, score: (0, embedder_1.cosineSimilarity)(queryEmbedding, attrs.embedding) });
+        });
+    }
+    if (useBm25) {
+        const bm25Scores = bm25Index.score(queryText);
+        const positiveScored = useVector ? scored.filter(s => s.score > 0) : [];
+        if (positiveScored.length > 0) {
+            const vectorMap = new Map(positiveScored.map(s => [s.id, s.score]));
+            const fused = (0, bm25_1.rrfFuse)(vectorMap, bm25Scores, rrfK);
+            scored.length = 0;
+            for (const [id, score] of fused)
+                scored.push({ id, score });
+        }
+        else {
+            scored.length = 0;
+            for (const [id, score] of bm25Scores)
+                scored.push({ id, score });
+        }
+        // Normalize scores to 0–1 so minScore threshold works uniformly
+        const maxScore = scored.reduce((m, s) => Math.max(m, s.score), 0);
+        if (maxScore > 0) {
+            for (const s of scored)
+                s.score /= maxScore;
+        }
+    }
+    if (scored.length === 0)
+        return [];
+    scored.sort((a, b) => b.score - a.score);
+    // --- 2. Filter seeds ---
+    const minS = minScore;
+    const seeds = scored.filter(s => s.score >= minS).slice(0, topK);
+    if (seeds.length === 0)
+        return [];
+    // --- 3. BFS expansion ---
+    const scoreMap = new Map(seeds.map(s => [s.id, s.score]));
+    function bfs(startId, seedScore) {
+        const queue = [
+            { id: startId, depth: 0, score: seedScore },
+        ];
+        const visited = new Set();
+        while (queue.length > 0) {
+            const item = queue.shift();
+            if (visited.has(item.id))
+                continue;
+            visited.add(item.id);
+            const prev = scoreMap.get(item.id) ?? -Infinity;
+            if (item.score > prev)
+                scoreMap.set(item.id, item.score);
+            if (item.depth >= bfsDepth)
+                continue;
+            if (item.score * bfsDecay < minS)
+                continue;
+            const nextScore = item.score * bfsDecay;
+            graph.outNeighbors(item.id).forEach(n => queue.push({ id: n, depth: item.depth + 1, score: nextScore }));
+            graph.inNeighbors(item.id).forEach(n => queue.push({ id: n, depth: item.depth + 1, score: nextScore }));
+        }
+    }
+    for (const seed of seeds) {
+        bfs(seed.id, seed.score);
+    }
+    // --- 4. Build results (exclude proxy nodes) ---
+    return [...scoreMap.entries()]
+        .filter(([id, score]) => score >= minS && !graph.getNodeAttribute(id, 'proxyFor'))
+        .map(([id, score]) => {
+        const attrs = graph.getNodeAttributes(id);
+        return {
+            id,
+            title: attrs.title,
+            description: attrs.description,
+            status: attrs.status,
+            priority: attrs.priority,
+            tags: attrs.tags,
+            score,
+        };
+    })
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxResults);
+}

package/dist/lib/watcher.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWatcher = startWatcher;
+const chokidar_1 = __importDefault(require("chokidar"));
+const micromatch_1 = __importDefault(require("micromatch"));
+const path_1 = __importDefault(require("path"));
+/** Directories that are always excluded from watching (heavy, never useful). */
+const ALWAYS_IGNORED = ['.git', 'node_modules', '.next', '.nuxt', '.turbo', 'dist', 'build', '.graph-memory', '.notes', '.tasks', '.skills'];
+// chokidar 5: watch the directory directly — glob patterns don't fire 'add' for existing files
+function startWatcher(dir, handlers, pattern = '**/*.md', excludePatterns) {
+    const matches = (filePath) => {
+        const rel = path_1.default.relative(dir, filePath);
+        if (excludePatterns && excludePatterns.length > 0 && micromatch_1.default.isMatch(rel, excludePatterns))
+            return false;
+        return micromatch_1.default.isMatch(rel, pattern);
+    };
+    // chokidar 5 `ignored` accepts a function — use micromatch for glob exclude patterns
+    // plus always skip heavy directories (.git, node_modules, etc.)
+    const alwaysIgnoredSet = new Set(ALWAYS_IGNORED.map(d => path_1.default.join(dir, d)));
+    const ignored = (filePath) => {
+        // Always ignore heavy directories by exact basename match
+        if (alwaysIgnoredSet.has(filePath))
+            return true;
+        // User-defined exclude patterns (glob-based)
+        if (excludePatterns && excludePatterns.length > 0) {
+            const rel = path_1.default.relative(dir, filePath);
+            if (micromatch_1.default.isMatch(rel, excludePatterns))
+                return true;
+        }
+        return false;
+    };
+    let resolveReady;
+    const whenReady = new Promise(resolve => {
+        resolveReady = resolve;
+    });
+    const watcher = chokidar_1.default.watch(dir, {
+        ignoreInitial: false,
+        persistent: true,
+        ignored,
+    });
+    watcher.on('add', (filePath) => {
+        if (matches(filePath))
+            handlers.onAdd(filePath);
+    });
+    watcher.on('change', (filePath) => {
+        if (matches(filePath))
+            handlers.onChange(filePath);
+    });
+    watcher.on('unlink', (filePath) => {
+        if (matches(filePath))
+            handlers.onUnlink(filePath);
+    });
+    watcher.on('ready', () => {
+        process.stderr.write(`[watcher] Ready. Watching ${dir}\n`);
+        resolveReady();
+    });
+    watcher.on('error', (err) => {
+        process.stderr.write(`[watcher] Watch error: ${err}\n`);
+    });
+    return {
+        whenReady,
+        close: () => watcher.close(),
+    };
+}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@prih/mcp-graph-memory",
+  "version": "1.0.3",
+  "description": "MCP server for semantic graph memory from markdown files",
+  "main": "dist/cli/index.js",
+  "bin": {
+    "mcp-graph-memory": "dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "npm run build:server && npm run build:ui",
+    "build:server": "rm -rf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "build:ui": "cd ui && npm run build",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "cli": "node dist/cli/index.js",
+    "cli:dev": "tsx src/cli/index.ts",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prih/mcp-graph-memory.git"
+  },
+  "homepage": "https://github.com/prih/mcp-graph-memory",
+  "bugs": "https://github.com/prih/mcp-graph-memory/issues",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "graph",
+    "memory",
+    "semantic-search",
+    "knowledge-graph",
+    "embeddings",
+    "documentation",
+    "code-indexing"
+  ],
+  "author": "prih <prihmail@gmail.com>",
+  "license": "ISC",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist/",
+    "ui/dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^3.8.1",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.3",
+    "cors": "^2.8.6",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "graphology": "^0.26.0",
+    "micromatch": "^4.0.8",
+    "mime": "^4.1.0",
+    "multer": "^2.1.1",
+    "ts-morph": "^27.0.2",
+    "ws": "^8.19.0",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/jest": "^30.0.0",
+    "@types/micromatch": "^4.0.10",
+    "@types/multer": "^2.1.0",
+    "@types/node": "^25.4.0",
+    "@types/supertest": "^7.2.0",
+    "@types/ws": "^8.18.1",
+    "jest": "^30.3.0",
+    "supertest": "^7.2.2",
+    "ts-jest": "^29.4.6",
+    "tsc-alias": "^1.8.16",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/ui/README.md

@@ -0,0 +1,54 @@
+# Graph Memory — Web UI
+
+React web interface for browsing and managing graph memory data.
+
+## Tech Stack
+
+| Library | Version | Purpose |
+|---------|---------|---------|
+| React | 19 | UI framework |
+| Material UI (MUI) | 7 | Component library |
+| React Router DOM | 7 | Client-side routing |
+| Cytoscape.js | 3.33 | Graph visualization |
+| Vite | 8 | Build tool + dev server |
+
+## Architecture
+
+Feature-Sliced Design (FSD):
+
+```
+src/
+├── app/             # Routes, theme, global styles
+├── pages/           # Dashboard, Knowledge, Tasks, Skills, Docs, Files, Prompts, Search, Graph, Tools, Help
+├── widgets/         # Layout (sidebar + project selector + theme toggle)
+├── features/        # note-crud, task-crud, skill-crud
+├── entities/        # project, note, task, skill, file, doc, code, graph
+├── shared/          # API client, WebSocket hook, theme context
+└── content/         # Help articles + prompt templates (markdown, bundled via ?raw)
+```
+
+## Development
+
+```bash
+npm install
+npm run dev          # Vite dev server on :5173, proxies /api → http://localhost:3000
+npm run build        # Production build → dist/
+```
+
+The backend (`serve` command) must be running on port 3000 for the API proxy to work.
+
+## Pages
+
+| Route | Description |
+|-------|-------------|
+| `/:projectId/dashboard` | Stats cards + recent notes/tasks |
+| `/:projectId/knowledge` | Notes CRUD, search, relations, cross-graph links |
+| `/:projectId/tasks` | Kanban board: configurable columns, drag-drop with highlights, inline creation, filters, due date/estimate badges, quick actions |
+| `/:projectId/docs` | Browse indexed documentation, TOC |
+| `/:projectId/files` | File browser, directory navigation, metadata |
+| `/:projectId/skills` | Skill/recipe management with triggers, steps, usage tracking |
+| `/:projectId/prompts` | AI prompt generator: scenarios, role/style/graph selection, live preview, export as skill |
+| `/:projectId/search` | Unified search across all 6 graphs |
+| `/:projectId/graph` | Interactive force-directed graph (Cytoscape.js) |
+| `/:projectId/tools` | MCP tools explorer with live execution |
+| `/:projectId/help` | Built-in searchable documentation |