mindpm 1.1.2 → 1.2.0

package/README.md

@@ -1,168 +1,168 @@
-# mindpm
-
-**Persistent project memory for LLMs.** Never re-explain your project again.
-
-mindpm is an MCP (Model Context Protocol) server that gives LLMs a SQLite-backed brain for your projects. It tracks tasks, decisions, architecture notes, and session context — so every new conversation picks up exactly where you left off.
-
-## The Problem
-
-Every new LLM chat starts from zero:
-
-- *"Let me remind you about my project..."*
-- *"Last time we decided to use Redis for..."*
-- *"Where did we leave off?"*
-
-## The Solution
-
-mindpm persists your project state in a local SQLite database. The LLM reads and writes to it via MCP tools. No chat history needed. No memory features needed.
-
-```
-You: "What should I work on next?"
-LLM: [queries mindpm] "Last session you finished the auth refactor.
-      You have 3 high-priority tasks: rate limiting, API docs, and
-      the webhook retry bug. Rate limiting is unblocked — start there."
-```
-
-## What It Tracks
-
-- **Tasks** — status, priority, blockers, sub-tasks
-- **Decisions** — what was decided, why, what alternatives were rejected
-- **Notes** — architecture, bugs, ideas, research
-- **Context** — key-value pairs (tech stack, conventions, config)
-- **Sessions** — what was done, what's next
-
-## Setup
-
-### Install
-
-```bash
-npm install -g mindpm
-```
-
-Or run from source:
-
-```bash
-git clone https://github.com/umitkavala/mindpm.git
-cd mindpm
-npm install
-npm run build
-```
-
-### Configure with Claude Code
-
-Add to your MCP config (`~/.claude/claude_desktop_config.json` or similar):
-
-```json
-{
-  "mcpServers": {
-    "mindpm": {
-      "command": "mindpm",
-      "env": {
-        "MINDPM_DB_PATH": "~/.mindpm/memory.db"
-      }
-    }
-  }
-}
-```
-
-If running from source, use the built file directly:
-
-```json
-{
-  "mcpServers": {
-    "mindpm": {
-      "command": "node",
-      "args": ["/path/to/mindpm/dist/index.js"],
-      "env": {
-        "MINDPM_DB_PATH": "~/.mindpm/memory.db"
-      }
-    }
-  }
-}
-```
-
-### Start Using
-
-That's it. The LLM now has access to mindpm tools. Just start talking about your projects.
-
-## MCP Tools
-
-### Projects
-| Tool | Description |
-|------|-------------|
-| `create_project` | Create a new project |
-| `list_projects` | List all projects |
-| `get_project_status` | Full project overview |
-
-### Tasks
-| Tool | Description |
-|------|-------------|
-| `create_task` | Add a task |
-| `update_task` | Update status, priority, etc. |
-| `list_tasks` | List with filters |
-| `get_task` | Full task detail with sub-tasks and notes |
-| `get_next_tasks` | Smart: highest priority, unblocked |
-
-### Decisions
-| Tool | Description |
-|------|-------------|
-| `log_decision` | Record a decision with reasoning |
-| `list_decisions` | Browse decision history |
-
-### Notes & Context
-| Tool | Description |
-|------|-------------|
-| `add_note` | Add a note (architecture, bug, idea, etc.) |
-| `search_notes` | Full-text search |
-| `set_context` | Store key-value context |
-| `get_context` | Retrieve context |
-
-### Sessions
-| Tool | Description |
-|------|-------------|
-| `start_session` | Get full project context + last session's next steps |
-| `end_session` | Record summary + what to do next time |
-
-### Query
-| Tool | Description |
-|------|-------------|
-| `query` | Read-only SQL against the database |
-| `get_project_summary` | Tasks by status, blockers, recent activity |
-| `get_blockers` | All blocked tasks with what's blocking them |
-| `search` | Full-text search across everything |
-
-## How It Works
-
-```
-┌─────────────┐     MCP      ┌─────────┐     SQLite     ┌──────────┐
-│  Claude Code │ ◄──────────► │ mindpm  │ ◄────────────► │ memory.db│
-│  / Desktop   │   tools      │ server  │   read/write   │          │
-└─────────────┘               └─────────┘                └──────────┘
-```
-
-1. You start a conversation and mention your project
-2. The LLM calls `start_session` → gets full context
-3. During the conversation, it creates tasks, logs decisions, adds notes
-4. When you're done, it calls `end_session` → saves what's next
-5. Next conversation: instant context, zero re-explanation
-
-## Storage
-
-Default: `~/.mindpm/memory.db`
-
-Override with `MINDPM_DB_PATH` or `PROJECT_MEMORY_DB_PATH` environment variable.
-
-Database and tables are created automatically on first run.
-
-## Development
-
-```bash
-npm install
-npm run build       # Build with tsup
-npm run typecheck   # Type-check without emitting
-npm run dev         # Build in watch mode
-```
-
-## License
-
-MIT
+# mindpm
+
+**Persistent project memory for LLMs.** Never re-explain your project again.
+
+mindpm is an MCP (Model Context Protocol) server that gives LLMs a SQLite-backed brain for your projects. It tracks tasks, decisions, architecture notes, and session context — so every new conversation picks up exactly where you left off.
+
+## The Problem
+
+Every new LLM chat starts from zero:
+
+- *"Let me remind you about my project..."*
+- *"Last time we decided to use Redis for..."*
+- *"Where did we leave off?"*
+
+## The Solution
+
+mindpm persists your project state in a local SQLite database. The LLM reads and writes to it via MCP tools. No chat history needed. No memory features needed.
+
+```
+You: "What should I work on next?"
+LLM: [queries mindpm] "Last session you finished the auth refactor.
+      You have 3 high-priority tasks: rate limiting, API docs, and
+      the webhook retry bug. Rate limiting is unblocked — start there."
+```
+
+## What It Tracks
+
+- **Tasks** — status, priority, blockers, sub-tasks
+- **Decisions** — what was decided, why, what alternatives were rejected
+- **Notes** — architecture, bugs, ideas, research
+- **Context** — key-value pairs (tech stack, conventions, config)
+- **Sessions** — what was done, what's next
+
+## Setup
+
+### Install
+
+```bash
+npm install -g mindpm
+```
+
+Or run from source:
+
+```bash
+git clone https://github.com/umitkavala/mindpm.git
+cd mindpm
+npm install
+npm run build
+```
+
+### Configure with Claude Code
+
+Add to your MCP config (`~/.claude/claude_desktop_config.json` or similar):
+
+```json
+{
+  "mcpServers": {
+    "mindpm": {
+      "command": "mindpm",
+      "env": {
+        "MINDPM_DB_PATH": "~/.mindpm/memory.db"
+      }
+    }
+  }
+}
+```
+
+If running from source, use the built file directly:
+
+```json
+{
+  "mcpServers": {
+    "mindpm": {
+      "command": "node",
+      "args": ["/path/to/mindpm/dist/index.js"],
+      "env": {
+        "MINDPM_DB_PATH": "~/.mindpm/memory.db"
+      }
+    }
+  }
+}
+```
+
+### Start Using
+
+That's it. The LLM now has access to mindpm tools. Just start talking about your projects.
+
+## MCP Tools
+
+### Projects
+| Tool | Description |
+|------|-------------|
+| `create_project` | Create a new project |
+| `list_projects` | List all projects |
+| `get_project_status` | Full project overview |
+
+### Tasks
+| Tool | Description |
+|------|-------------|
+| `create_task` | Add a task |
+| `update_task` | Update status, priority, etc. |
+| `list_tasks` | List with filters |
+| `get_task` | Full task detail with sub-tasks and notes |
+| `get_next_tasks` | Smart: highest priority, unblocked |
+
+### Decisions
+| Tool | Description |
+|------|-------------|
+| `log_decision` | Record a decision with reasoning |
+| `list_decisions` | Browse decision history |
+
+### Notes & Context
+| Tool | Description |
+|------|-------------|
+| `add_note` | Add a note (architecture, bug, idea, etc.) |
+| `search_notes` | Full-text search |
+| `set_context` | Store key-value context |
+| `get_context` | Retrieve context |
+
+### Sessions
+| Tool | Description |
+|------|-------------|
+| `start_session` | Get full project context + last session's next steps |
+| `end_session` | Record summary + what to do next time |
+
+### Query
+| Tool | Description |
+|------|-------------|
+| `query` | Read-only SQL against the database |
+| `get_project_summary` | Tasks by status, blockers, recent activity |
+| `get_blockers` | All blocked tasks with what's blocking them |
+| `search` | Full-text search across everything |
+
+## How It Works
+
+```
+┌─────────────┐     MCP      ┌─────────┐     SQLite     ┌──────────┐
+│  Claude Code │ ◄──────────► │ mindpm  │ ◄────────────► │ memory.db│
+│  / Desktop   │   tools      │ server  │   read/write   │          │
+└─────────────┘               └─────────┘                └──────────┘
+```
+
+1. You start a conversation and mention your project
+2. The LLM calls `start_session` → gets full context
+3. During the conversation, it creates tasks, logs decisions, adds notes
+4. When you're done, it calls `end_session` → saves what's next
+5. Next conversation: instant context, zero re-explanation
+
+## Storage
+
+Default: `~/.mindpm/memory.db`
+
+Override with `MINDPM_DB_PATH` or `PROJECT_MEMORY_DB_PATH` environment variable.
+
+Database and tables are created automatically on first run.
+
+## Development
+
+```bash
+npm install
+npm run build       # Build with tsup
+npm run typecheck   # Type-check without emitting
+npm run dev         # Build in watch mode
+```
+
+## License
+
+MIT

package/dist/index.js

@@ -1002,11 +1002,328 @@ function registerQueryTools(server2) {
   );
 }
 
+// src/server/http.ts
+import { createServer } from "http";
+import { readFile } from "fs/promises";
+import { join, extname } from "path";
+import { fileURLToPath } from "url";
+import { dirname as dirname2 } from "path";
+
+// src/server/routes.ts
+var listProjects = async (_req, res) => {
+  const db2 = getDb();
+  const url = new URL(_req.url || "/", "http://localhost");
+  const status = url.searchParams.get("status");
+  let rows;
+  if (status) {
+    rows = db2.prepare("SELECT * FROM projects WHERE status = ? ORDER BY updated_at DESC").all(status);
+  } else {
+    rows = db2.prepare("SELECT * FROM projects ORDER BY updated_at DESC").all();
+  }
+  sendJson(res, 200, rows);
+};
+var getProject = async (_req, res, params) => {
+  const db2 = getDb();
+  const project = db2.prepare("SELECT * FROM projects WHERE id = ?").get(params.id);
+  if (!project) {
+    sendJson(res, 404, { error: "Project not found" });
+    return;
+  }
+  const taskCounts = db2.prepare("SELECT status, COUNT(*) as count FROM tasks WHERE project_id = ? GROUP BY status").all(params.id);
+  sendJson(res, 200, { ...project, task_counts: taskCounts });
+};
+var updateProject = async (req, res, params) => {
+  const db2 = getDb();
+  const body = await parseBody(req);
+  const existing = db2.prepare("SELECT * FROM projects WHERE id = ?").get(params.id);
+  if (!existing) {
+    sendJson(res, 404, { error: "Project not found" });
+    return;
+  }
+  const updates = [];
+  const sqlParams = [];
+  if (body.name !== void 0) {
+    updates.push("name = ?");
+    sqlParams.push(body.name);
+  }
+  if (body.description !== void 0) {
+    updates.push("description = ?");
+    sqlParams.push(body.description);
+  }
+  if (body.status !== void 0) {
+    updates.push("status = ?");
+    sqlParams.push(body.status);
+  }
+  if (updates.length === 0) {
+    sendJson(res, 400, { error: "No updates provided" });
+    return;
+  }
+  sqlParams.push(params.id);
+  try {
+    db2.prepare(`UPDATE projects SET ${updates.join(", ")} WHERE id = ?`).run(...sqlParams);
+  } catch (e) {
+    if (e.message?.includes("UNIQUE constraint failed")) {
+      sendJson(res, 409, { error: "A project with that name already exists" });
+      return;
+    }
+    throw e;
+  }
+  const updated = db2.prepare("SELECT * FROM projects WHERE id = ?").get(params.id);
+  sendJson(res, 200, updated);
+};
+var listTasks = async (req, res, params) => {
+  const db2 = getDb();
+  const url = new URL(req.url || "/", "http://localhost");
+  const includeDone = url.searchParams.get("include_done") === "true";
+  let sql = "SELECT * FROM tasks WHERE project_id = ?";
+  if (!includeDone) {
+    sql += " AND status NOT IN ('done', 'cancelled')";
+  }
+  sql += " ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END, created_at DESC";
+  const rows = db2.prepare(sql).all(params.pid);
+  sendJson(res, 200, rows);
+};
+var createTask = async (req, res, params) => {
+  const db2 = getDb();
+  const body = await parseBody(req);
+  if (!body.title || typeof body.title !== "string") {
+    sendJson(res, 400, { error: "title is required" });
+    return;
+  }
+  const project = db2.prepare("SELECT id FROM projects WHERE id = ?").get(params.pid);
+  if (!project) {
+    sendJson(res, 404, { error: "Project not found" });
+    return;
+  }
+  const id = generateId();
+  const priority = body.priority || "medium";
+  const tags = Array.isArray(body.tags) ? JSON.stringify(body.tags) : null;
+  db2.prepare(
+    "INSERT INTO tasks (id, project_id, title, description, priority, tags, parent_task_id) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ).run(
+    id,
+    params.pid,
+    body.title,
+    body.description ?? null,
+    priority,
+    tags,
+    body.parent_task_id ?? null
+  );
+  const task = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+  sendJson(res, 201, task);
+};
+var updateTask = async (req, res, params) => {
+  const db2 = getDb();
+  const body = await parseBody(req);
+  const existing = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(params.id);
+  if (!existing) {
+    sendJson(res, 404, { error: "Task not found" });
+    return;
+  }
+  const updates = [];
+  const sqlParams = [];
+  if (body.title !== void 0) {
+    updates.push("title = ?");
+    sqlParams.push(body.title);
+  }
+  if (body.description !== void 0) {
+    updates.push("description = ?");
+    sqlParams.push(body.description);
+  }
+  if (body.status !== void 0) {
+    updates.push("status = ?");
+    sqlParams.push(body.status);
+    if (body.status === "done") {
+      updates.push("completed_at = CURRENT_TIMESTAMP");
+    } else {
+      updates.push("completed_at = NULL");
+    }
+  }
+  if (body.priority !== void 0) {
+    updates.push("priority = ?");
+    sqlParams.push(body.priority);
+  }
+  if (body.tags !== void 0) {
+    updates.push("tags = ?");
+    sqlParams.push(Array.isArray(body.tags) ? JSON.stringify(body.tags) : null);
+  }
+  if (body.blocked_by !== void 0) {
+    updates.push("blocked_by = ?");
+    sqlParams.push(Array.isArray(body.blocked_by) ? JSON.stringify(body.blocked_by) : null);
+    if (Array.isArray(body.blocked_by) && body.blocked_by.length > 0 && body.status === void 0) {
+      updates.push("status = 'blocked'");
+    }
+  }
+  if (updates.length === 0) {
+    sendJson(res, 400, { error: "No updates provided" });
+    return;
+  }
+  sqlParams.push(params.id);
+  db2.prepare(`UPDATE tasks SET ${updates.join(", ")} WHERE id = ?`).run(...sqlParams);
+  const updated = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(params.id);
+  sendJson(res, 200, updated);
+};
+var deleteTask = async (_req, res, params) => {
+  const db2 = getDb();
+  const existing = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(params.id);
+  if (!existing) {
+    sendJson(res, 404, { error: "Task not found" });
+    return;
+  }
+  const deleteTransaction = db2.transaction((taskId) => {
+    const subtasks = db2.prepare("SELECT id FROM tasks WHERE parent_task_id = ?").all(taskId);
+    for (const sub of subtasks) {
+      db2.prepare("DELETE FROM notes WHERE task_id = ?").run(sub.id);
+      db2.prepare("DELETE FROM tasks WHERE id = ?").run(sub.id);
+    }
+    db2.prepare("DELETE FROM notes WHERE task_id = ?").run(taskId);
+    db2.prepare("DELETE FROM tasks WHERE id = ?").run(taskId);
+  });
+  deleteTransaction(params.id);
+  sendJson(res, 200, { message: "Task deleted" });
+};
+var routes = [
+  { method: "GET", pattern: "/api/projects", handler: listProjects },
+  { method: "GET", pattern: "/api/projects/:id", handler: getProject },
+  { method: "PATCH", pattern: "/api/projects/:id", handler: updateProject },
+  { method: "GET", pattern: "/api/projects/:pid/tasks", handler: listTasks },
+  { method: "POST", pattern: "/api/projects/:pid/tasks", handler: createTask },
+  { method: "PATCH", pattern: "/api/tasks/:id", handler: updateTask },
+  { method: "DELETE", pattern: "/api/tasks/:id", handler: deleteTask }
+];
+async function handleApiRequest(req, res) {
+  const url = new URL(req.url || "/", "http://localhost");
+  const method = req.method || "GET";
+  for (const route of routes) {
+    if (route.method !== method) continue;
+    const params = matchRoute(route.pattern, url.pathname);
+    if (params) {
+      await route.handler(req, res, params);
+      return;
+    }
+  }
+  sendJson(res, 404, { error: "Not found" });
+}
+
+// src/server/http.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+function resolveStaticDir() {
+  const scriptDir = dirname2(process.argv[1] || __filename);
+  return join(scriptDir, "ui");
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf"
+};
+function parseBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      if (chunks.length === 0) {
+        resolve2({});
+        return;
+      }
+      try {
+        resolve2(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch {
+        resolve2({});
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function matchRoute(pattern, pathname) {
+  const patternParts = pattern.split("/").filter(Boolean);
+  const pathParts = pathname.split("/").filter(Boolean);
+  if (patternParts.length !== pathParts.length) return null;
+  const params = {};
+  for (let i = 0; i < patternParts.length; i++) {
+    if (patternParts[i].startsWith(":")) {
+      params[patternParts[i].slice(1)] = decodeURIComponent(pathParts[i]);
+    } else if (patternParts[i] !== pathParts[i]) {
+      return null;
+    }
+  }
+  return params;
+}
+function sendJson(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(data));
+}
+async function serveStatic(req, res) {
+  const staticDir = resolveStaticDir();
+  const url = new URL(req.url || "/", "http://localhost");
+  let filePath = join(staticDir, url.pathname === "/" ? "index.html" : url.pathname);
+  try {
+    const content = await readFile(filePath);
+    const ext = extname(filePath);
+    const contentType = MIME_TYPES[ext] || "application/octet-stream";
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(content);
+  } catch {
+    try {
+      const indexPath = join(staticDir, "index.html");
+      const content = await readFile(indexPath);
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(content);
+    } catch {
+      res.writeHead(503, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(
+        "<html><body><h1>mindpm UI not built</h1><p>Run <code>npm run build:ui</code> to build the Kanban UI.</p></body></html>"
+      );
+    }
+  }
+}
+function startHttpServer(port) {
+  const server2 = createServer(async (req, res) => {
+    try {
+      if (req.url?.startsWith("/api/")) {
+        await handleApiRequest(req, res);
+      } else {
+        await serveStatic(req, res);
+      }
+    } catch (err) {
+      process.stderr.write(`[mindpm] HTTP error: ${err}
+`);
+      if (!res.headersSent) {
+        sendJson(res, 500, { error: "Internal server error" });
+      }
+    }
+  });
+  server2.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      process.stderr.write(
+        `[mindpm] Warning: Port ${port} is in use. Kanban UI not available. MCP server continues.
+`
+      );
+    } else {
+      process.stderr.write(`[mindpm] HTTP server error: ${err.message}
+`);
+    }
+  });
+  server2.listen(port, () => {
+    process.stderr.write(`[mindpm] Kanban UI available at http://localhost:${port}
+`);
+  });
+  return server2;
+}
+
 // src/index.ts
 var server = new McpServer(
   {
     name: "mindpm",
-    version: "1.1.2"
+    version: "1.2.0"
   },
   {
     capabilities: {
@@ -1020,21 +1337,27 @@ registerDecisionTools(server);
 registerNoteTools(server);
 registerSessionTools(server);
 registerQueryTools(server);
+var httpServer;
 async function main() {
   ensureDbDirectory();
+  const port = parseInt(process.env.MINDPM_PORT || "3131", 10);
+  httpServer = startHttpServer(port);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
 main().catch((error) => {
   console.error("Fatal error:", error);
+  httpServer?.close();
   closeDb();
   process.exit(1);
 });
 process.on("SIGINT", () => {
+  httpServer?.close();
   closeDb();
   process.exit(0);
 });
 process.on("SIGTERM", () => {
+  httpServer?.close();
   closeDb();
   process.exit(0);
 });