mindpm 1.0.0

package/dist/index.js

@@ -0,0 +1,981 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/projects.ts
+import { z } from "zod/v4";
+
+// src/db/connection.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+import { homedir } from "os";
+
+// src/db/schema.ts
+function createSchema(db2) {
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT,
+      status TEXT DEFAULT 'active' CHECK(status IN ('active', 'paused', 'completed', 'archived')),
+      repo_path TEXT,
+      tech_stack TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id),
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT DEFAULT 'todo' CHECK(status IN ('todo', 'in_progress', 'blocked', 'done', 'cancelled')),
+      priority TEXT DEFAULT 'medium' CHECK(priority IN ('critical', 'high', 'medium', 'low')),
+      tags TEXT,
+      parent_task_id TEXT REFERENCES tasks(id),
+      blocked_by TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      completed_at DATETIME
+    );
+
+    CREATE TABLE IF NOT EXISTS decisions (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id),
+      title TEXT NOT NULL,
+      decision TEXT NOT NULL,
+      reasoning TEXT,
+      alternatives TEXT,
+      tags TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS notes (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id),
+      task_id TEXT REFERENCES tasks(id),
+      content TEXT NOT NULL,
+      category TEXT DEFAULT 'general' CHECK(category IN ('general', 'architecture', 'bug', 'idea', 'research', 'meeting', 'review')),
+      tags TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id),
+      summary TEXT NOT NULL,
+      tasks_worked_on TEXT,
+      decisions_made TEXT,
+      next_steps TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS context (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id),
+      key TEXT NOT NULL,
+      value TEXT NOT NULL,
+      category TEXT DEFAULT 'general',
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE(project_id, key)
+    );
+
+    -- Indexes
+    CREATE INDEX IF NOT EXISTS idx_tasks_project_id ON tasks(project_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+    CREATE INDEX IF NOT EXISTS idx_tasks_created_at ON tasks(created_at);
+
+    CREATE INDEX IF NOT EXISTS idx_decisions_project_id ON decisions(project_id);
+    CREATE INDEX IF NOT EXISTS idx_decisions_created_at ON decisions(created_at);
+
+    CREATE INDEX IF NOT EXISTS idx_notes_project_id ON notes(project_id);
+    CREATE INDEX IF NOT EXISTS idx_notes_task_id ON notes(task_id);
+    CREATE INDEX IF NOT EXISTS idx_notes_category ON notes(category);
+    CREATE INDEX IF NOT EXISTS idx_notes_created_at ON notes(created_at);
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_project_id ON sessions(project_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_created_at ON sessions(created_at);
+
+    CREATE INDEX IF NOT EXISTS idx_context_project_id ON context(project_id);
+
+    -- Triggers for updated_at (WHEN clause prevents infinite recursion)
+    CREATE TRIGGER IF NOT EXISTS trg_projects_updated_at
+    AFTER UPDATE ON projects
+    FOR EACH ROW
+    WHEN NEW.updated_at = OLD.updated_at
+    BEGIN
+      UPDATE projects SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS trg_tasks_updated_at
+    AFTER UPDATE ON tasks
+    FOR EACH ROW
+    WHEN NEW.updated_at = OLD.updated_at
+    BEGIN
+      UPDATE tasks SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS trg_context_updated_at
+    AFTER UPDATE ON context
+    FOR EACH ROW
+    WHEN NEW.updated_at = OLD.updated_at
+    BEGIN
+      UPDATE context SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
+    END;
+  `);
+}
+
+// src/db/connection.ts
+var db = null;
+function resolveDbPath() {
+  const envPath = process.env.MINDPM_DB_PATH || process.env.PROJECT_MEMORY_DB_PATH;
+  if (envPath) {
+    return envPath.replace(/^~/, homedir());
+  }
+  return resolve(homedir(), ".mindpm", "memory.db");
+}
+function getDb() {
+  if (db) return db;
+  const dbPath = resolveDbPath();
+  mkdirSync(dirname(dbPath), { recursive: true });
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  createSchema(db);
+  return db;
+}
+function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+
+// src/utils/ids.ts
+import { randomBytes } from "crypto";
+function generateId() {
+  return randomBytes(4).toString("hex");
+}
+
+// src/db/queries.ts
+function resolveProjectId(projectRef) {
+  const db2 = getDb();
+  const byId = db2.prepare("SELECT id FROM projects WHERE id = ?").get(projectRef);
+  if (byId) return byId.id;
+  const byName = db2.prepare("SELECT id FROM projects WHERE LOWER(name) = LOWER(?)").get(projectRef);
+  if (byName) return byName.id;
+  return null;
+}
+function getMostRecentProject() {
+  const db2 = getDb();
+  const row = db2.prepare(
+    `SELECT id, name FROM projects WHERE status = 'active' ORDER BY updated_at DESC LIMIT 1`
+  ).get();
+  return row ?? null;
+}
+function resolveProjectOrDefault(projectRef) {
+  const db2 = getDb();
+  if (projectRef) {
+    const id = resolveProjectId(projectRef);
+    if (!id) return null;
+    const row = db2.prepare("SELECT id, name FROM projects WHERE id = ?").get(id);
+    return row ?? null;
+  }
+  return getMostRecentProject();
+}
+
+// src/tools/projects.ts
+function registerProjectTools(server2) {
+  server2.registerTool(
+    "create_project",
+    {
+      title: "Create Project",
+      description: "Create a new project to track. Use this when starting a new project or when a user mentions a project that doesn't exist yet.",
+      inputSchema: {
+        name: z.string().describe("Project name (unique)"),
+        description: z.string().optional().describe("What this project is about"),
+        tech_stack: z.array(z.string()).optional().describe('Technologies used, e.g. ["FastAPI", "React", "PostgreSQL"]'),
+        repo_path: z.string().optional().describe("Path to the project repository")
+      }
+    },
+    async ({ name, description, tech_stack, repo_path }) => {
+      const db2 = getDb();
+      const id = generateId();
+      try {
+        db2.prepare(
+          `INSERT INTO projects (id, name, description, tech_stack, repo_path) VALUES (?, ?, ?, ?, ?)`
+        ).run(id, name, description ?? null, tech_stack ? JSON.stringify(tech_stack) : null, repo_path ?? null);
+      } catch (e) {
+        if (e.message?.includes("UNIQUE constraint failed")) {
+          return { content: [{ type: "text", text: `Project "${name}" already exists.` }], isError: true };
+        }
+        throw e;
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ project_id: id, message: `Project created: "${name}"` }) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "list_projects",
+    {
+      title: "List Projects",
+      description: "List all tracked projects. Filter by status to see active, paused, completed, or archived projects.",
+      inputSchema: {
+        status: z.enum(["active", "paused", "completed", "archived"]).optional().describe("Filter by project status")
+      }
+    },
+    async ({ status }) => {
+      const db2 = getDb();
+      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();
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(rows, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_project_status",
+    {
+      title: "Get Project Status",
+      description: "Get a full overview of a project: active tasks, recent decisions, blockers, and last session summary. Great for getting up to speed.",
+      inputSchema: {
+        project: z.string().describe("Project name or ID")
+      }
+    },
+    async ({ project }) => {
+      const db2 = getDb();
+      const projectId = resolveProjectId(project);
+      if (!projectId) {
+        return { content: [{ type: "text", text: `Project "${project}" not found.` }], isError: true };
+      }
+      const projectRow = db2.prepare("SELECT * FROM projects WHERE id = ?").get(projectId);
+      const activeTasks = db2.prepare("SELECT id, title, status, priority, tags FROM tasks WHERE project_id = ? AND status NOT IN ('done', 'cancelled') ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END").all(projectId);
+      const blockedTasks = db2.prepare("SELECT id, title, blocked_by FROM tasks WHERE project_id = ? AND status = 'blocked'").all(projectId);
+      const recentDecisions = db2.prepare("SELECT id, title, decision, created_at FROM decisions WHERE project_id = ? ORDER BY created_at DESC LIMIT 5").all(projectId);
+      const lastSession = db2.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY created_at DESC LIMIT 1").get(projectId);
+      const taskCounts = db2.prepare("SELECT status, COUNT(*) as count FROM tasks WHERE project_id = ? GROUP BY status").all(projectId);
+      const result = {
+        project: projectRow,
+        task_summary: taskCounts,
+        active_tasks: activeTasks,
+        blocked_tasks: blockedTasks,
+        recent_decisions: recentDecisions,
+        last_session: lastSession
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/tasks.ts
+import { z as z2 } from "zod/v4";
+function registerTaskTools(server2) {
+  server2.registerTool(
+    "create_task",
+    {
+      title: "Create Task",
+      description: "Create a new task in a project. Proactively use this when the user mentions something that needs to be done, a bug to fix, or a feature to build.",
+      inputSchema: {
+        project: z2.string().optional().describe("Project name or ID (defaults to most recent active project)"),
+        title: z2.string().describe("Short task title"),
+        description: z2.string().optional().describe("Detailed description of the task"),
+        priority: z2.enum(["critical", "high", "medium", "low"]).optional().describe("Task priority (default: medium)"),
+        tags: z2.array(z2.string()).optional().describe('Tags like "backend", "auth", "bug"'),
+        parent_task_id: z2.string().optional().describe("Parent task ID for sub-tasks")
+      }
+    },
+    async ({ project, title, description, priority, tags, parent_task_id }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found. Create a project first." }], isError: true };
+      }
+      const db2 = getDb();
+      const id = generateId();
+      db2.prepare(
+        `INSERT INTO tasks (id, project_id, title, description, priority, tags, parent_task_id) VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        id,
+        resolved.id,
+        title,
+        description ?? null,
+        priority ?? "medium",
+        tags ? JSON.stringify(tags) : null,
+        parent_task_id ?? null
+      );
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            task_id: id,
+            message: `Task created: "${title}" in ${resolved.name} (priority: ${priority ?? "medium"})`
+          })
+        }]
+      };
+    }
+  );
+  server2.registerTool(
+    "update_task",
+    {
+      title: "Update Task",
+      description: "Update any field of a task. Proactively use this when a task status changes, priorities shift, or new information comes in.",
+      inputSchema: {
+        task_id: z2.string().describe("Task ID to update"),
+        title: z2.string().optional().describe("New title"),
+        description: z2.string().optional().describe("New description"),
+        status: z2.enum(["todo", "in_progress", "blocked", "done", "cancelled"]).optional().describe("New status"),
+        priority: z2.enum(["critical", "high", "medium", "low"]).optional().describe("New priority"),
+        tags: z2.array(z2.string()).optional().describe("New tags (replaces existing)"),
+        blocked_by: z2.array(z2.string()).optional().describe("Task IDs that block this task")
+      }
+    },
+    async ({ task_id, title, description, status, priority, tags, blocked_by }) => {
+      const db2 = getDb();
+      const existing = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(task_id);
+      if (!existing) {
+        return { content: [{ type: "text", text: `Task "${task_id}" not found.` }], isError: true };
+      }
+      const updates = [];
+      const params = [];
+      if (title !== void 0) {
+        updates.push("title = ?");
+        params.push(title);
+      }
+      if (description !== void 0) {
+        updates.push("description = ?");
+        params.push(description);
+      }
+      if (status !== void 0) {
+        updates.push("status = ?");
+        params.push(status);
+        if (status === "done") {
+          updates.push("completed_at = CURRENT_TIMESTAMP");
+        }
+      }
+      if (priority !== void 0) {
+        updates.push("priority = ?");
+        params.push(priority);
+      }
+      if (tags !== void 0) {
+        updates.push("tags = ?");
+        params.push(JSON.stringify(tags));
+      }
+      if (blocked_by !== void 0) {
+        updates.push("blocked_by = ?");
+        params.push(JSON.stringify(blocked_by));
+        if (blocked_by.length > 0 && status === void 0) {
+          updates.push("status = 'blocked'");
+        }
+      }
+      if (updates.length === 0) {
+        return { content: [{ type: "text", text: "No updates provided." }], isError: true };
+      }
+      params.push(task_id);
+      db2.prepare(`UPDATE tasks SET ${updates.join(", ")} WHERE id = ?`).run(...params);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ task_id, message: `Task "${existing.title}" updated.` }) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "list_tasks",
+    {
+      title: "List Tasks",
+      description: "List tasks with filters. Defaults to showing non-completed tasks for the most recent active project.",
+      inputSchema: {
+        project: z2.string().optional().describe("Project name or ID"),
+        status: z2.enum(["todo", "in_progress", "blocked", "done", "cancelled"]).optional().describe("Filter by status"),
+        priority: z2.enum(["critical", "high", "medium", "low"]).optional().describe("Filter by priority"),
+        tag: z2.string().optional().describe("Filter by tag"),
+        include_done: z2.boolean().optional().describe("Include completed tasks (default: false)")
+      }
+    },
+    async ({ project, status, priority, tag, include_done }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found." }], isError: true };
+      }
+      const db2 = getDb();
+      const conditions = ["project_id = @projectId"];
+      const params = { projectId: resolved.id };
+      if (status) {
+        conditions.push("status = @status");
+        params.status = status;
+      } else if (!include_done) {
+        conditions.push("status NOT IN ('done', 'cancelled')");
+      }
+      if (priority) {
+        conditions.push("priority = @priority");
+        params.priority = priority;
+      }
+      if (tag) {
+        conditions.push("tags LIKE '%' || @tag || '%'");
+        params.tag = `"${tag}"`;
+      }
+      const sql = `SELECT * FROM tasks WHERE ${conditions.join(" AND ")} 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);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ project: resolved.name, tasks: rows }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_task",
+    {
+      title: "Get Task",
+      description: "Get full detail for a specific task including sub-tasks and related notes.",
+      inputSchema: {
+        task_id: z2.string().describe("Task ID")
+      }
+    },
+    async ({ task_id }) => {
+      const db2 = getDb();
+      const task = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(task_id);
+      if (!task) {
+        return { content: [{ type: "text", text: `Task "${task_id}" not found.` }], isError: true };
+      }
+      const subtasks = db2.prepare("SELECT * FROM tasks WHERE parent_task_id = ?").all(task_id);
+      const notes = db2.prepare("SELECT * FROM notes WHERE task_id = ? ORDER BY created_at DESC").all(task_id);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ task, subtasks, notes }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_next_tasks",
+    {
+      title: "Get Next Tasks",
+      description: "Smart query: what should be worked on next? Returns highest priority non-blocked tasks for a project.",
+      inputSchema: {
+        project: z2.string().optional().describe("Project name or ID"),
+        limit: z2.number().optional().describe("Max number of tasks to return (default: 5)")
+      }
+    },
+    async ({ project, limit }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found." }], isError: true };
+      }
+      const db2 = getDb();
+      const rows = db2.prepare(
+        `SELECT * FROM tasks
+           WHERE project_id = ? AND status IN ('todo', 'in_progress')
+           ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
+                    created_at ASC
+           LIMIT ?`
+      ).all(resolved.id, limit ?? 5);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ project: resolved.name, next_tasks: rows }, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/tools/decisions.ts
+import { z as z3 } from "zod/v4";
+function registerDecisionTools(server2) {
+  server2.registerTool(
+    "log_decision",
+    {
+      title: "Log Decision",
+      description: "Record a decision with reasoning and alternatives considered. Proactively use this when the user makes a technical decision, chooses between options, or settles a debate.",
+      inputSchema: {
+        project: z3.string().optional().describe("Project name or ID"),
+        title: z3.string().describe("Short title for the decision"),
+        decision: z3.string().describe("What was decided"),
+        reasoning: z3.string().optional().describe("Why this was decided"),
+        alternatives: z3.array(z3.string()).optional().describe("Rejected alternatives"),
+        tags: z3.array(z3.string()).optional().describe('Tags like "architecture", "database", "api"')
+      }
+    },
+    async ({ project, title, decision, reasoning, alternatives, tags }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found. Create a project first." }], isError: true };
+      }
+      const db2 = getDb();
+      const id = generateId();
+      db2.prepare(
+        `INSERT INTO decisions (id, project_id, title, decision, reasoning, alternatives, tags) VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        id,
+        resolved.id,
+        title,
+        decision,
+        reasoning ?? null,
+        alternatives ? JSON.stringify(alternatives) : null,
+        tags ? JSON.stringify(tags) : null
+      );
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ decision_id: id, message: `Decision logged: "${title}" in ${resolved.name}` })
+        }]
+      };
+    }
+  );
+  server2.registerTool(
+    "list_decisions",
+    {
+      title: "List Decisions",
+      description: "List decisions for a project. Filter by tags to find specific decisions.",
+      inputSchema: {
+        project: z3.string().optional().describe("Project name or ID"),
+        tag: z3.string().optional().describe("Filter by tag"),
+        limit: z3.number().optional().describe("Max number of decisions to return (default: 20)")
+      }
+    },
+    async ({ project, tag, limit }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found." }], isError: true };
+      }
+      const db2 = getDb();
+      let sql;
+      const params = [resolved.id];
+      if (tag) {
+        sql = `SELECT * FROM decisions WHERE project_id = ? AND tags LIKE ? ORDER BY created_at DESC LIMIT ?`;
+        params.push(`%"${tag}"%`, limit ?? 20);
+      } else {
+        sql = `SELECT * FROM decisions WHERE project_id = ? ORDER BY created_at DESC LIMIT ?`;
+        params.push(limit ?? 20);
+      }
+      const rows = db2.prepare(sql).all(...params);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ project: resolved.name, decisions: rows }, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/notes.ts
+import { z as z4 } from "zod/v4";
+function registerNoteTools(server2) {
+  server2.registerTool(
+    "add_note",
+    {
+      title: "Add Note",
+      description: "Add a note to a project or task. Proactively use this when the user shares context about architecture, bugs, ideas, research findings, or any important information worth remembering.",
+      inputSchema: {
+        project: z4.string().optional().describe("Project name or ID"),
+        content: z4.string().describe("The note content"),
+        category: z4.enum(["general", "architecture", "bug", "idea", "research", "meeting", "review"]).optional().describe("Note category (default: general)"),
+        task_id: z4.string().optional().describe("Link this note to a specific task"),
+        tags: z4.array(z4.string()).optional().describe("Tags for categorization")
+      }
+    },
+    async ({ project, content, category, task_id, tags }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found. Create a project first." }], isError: true };
+      }
+      const db2 = getDb();
+      const id = generateId();
+      db2.prepare(
+        `INSERT INTO notes (id, project_id, task_id, content, category, tags) VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(
+        id,
+        resolved.id,
+        task_id ?? null,
+        content,
+        category ?? "general",
+        tags ? JSON.stringify(tags) : null
+      );
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ note_id: id, message: `Note added to ${resolved.name} (${category ?? "general"})` })
+        }]
+      };
+    }
+  );
+  server2.registerTool(
+    "search_notes",
+    {
+      title: "Search Notes",
+      description: "Full-text search across notes for a project.",
+      inputSchema: {
+        project: z4.string().optional().describe("Project name or ID"),
+        query: z4.string().describe("Search query"),
+        category: z4.enum(["general", "architecture", "bug", "idea", "research", "meeting", "review"]).optional().describe("Filter by category")
+      }
+    },
+    async ({ project, query, category }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found." }], isError: true };
+      }
+      const db2 = getDb();
+      const conditions = ["project_id = ?"];
+      const params = [resolved.id];
+      conditions.push("content LIKE '%' || ? || '%'");
+      params.push(query);
+      if (category) {
+        conditions.push("category = ?");
+        params.push(category);
+      }
+      const sql = `SELECT * FROM notes WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC`;
+      const rows = db2.prepare(sql).all(...params);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ project: resolved.name, results: rows }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "set_context",
+    {
+      title: "Set Context",
+      description: "Set a key-value context pair for a project (upsert). Proactively use this when the user shares important project context like architecture decisions, config values, conventions, or constraints.",
+      inputSchema: {
+        project: z4.string().optional().describe("Project name or ID"),
+        key: z4.string().describe('Context key, e.g. "auth_approach", "deployment_target", "api_base_url"'),
+        value: z4.string().describe("Context value"),
+        category: z4.string().optional().describe('Category like "architecture", "config", "convention", "constraint"')
+      }
+    },
+    async ({ project, key, value, category }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found. Create a project first." }], isError: true };
+      }
+      const db2 = getDb();
+      const id = generateId();
+      db2.prepare(
+        `INSERT INTO context (id, project_id, key, value, category)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(project_id, key) DO UPDATE SET value = excluded.value, category = excluded.category`
+      ).run(id, resolved.id, key, value, category ?? "general");
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ message: `Context set: "${key}" = "${value}" in ${resolved.name}` })
+        }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_context",
+    {
+      title: "Get Context",
+      description: "Get context by key or list all context for a project.",
+      inputSchema: {
+        project: z4.string().optional().describe("Project name or ID"),
+        key: z4.string().optional().describe("Specific context key to retrieve. If omitted, returns all context.")
+      }
+    },
+    async ({ project, key }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found." }], isError: true };
+      }
+      const db2 = getDb();
+      let rows;
+      if (key) {
+        rows = db2.prepare("SELECT * FROM context WHERE project_id = ? AND key = ?").all(resolved.id, key);
+      } else {
+        rows = db2.prepare("SELECT * FROM context WHERE project_id = ? ORDER BY category, key").all(resolved.id);
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ project: resolved.name, context: rows }, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/sessions.ts
+import { z as z5 } from "zod/v4";
+function registerSessionTools(server2) {
+  server2.registerTool(
+    "start_session",
+    {
+      title: "Start Session",
+      description: "Begin a work session for a project. Returns the full project overview including last session's next_steps, active tasks, blockers, and recent decisions. Call this at the start of every conversation.",
+      inputSchema: {
+        project: z5.string().optional().describe("Project name or ID")
+      }
+    },
+    async ({ project }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found. Create a project first." }], isError: true };
+      }
+      const db2 = getDb();
+      const projectRow = db2.prepare("SELECT * FROM projects WHERE id = ?").get(resolved.id);
+      const lastSession = db2.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY created_at DESC LIMIT 1").get(resolved.id);
+      const activeTasks = db2.prepare(
+        `SELECT id, title, status, priority, tags FROM tasks
+           WHERE project_id = ? AND status NOT IN ('done', 'cancelled')
+           ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END`
+      ).all(resolved.id);
+      const blockedTasks = db2.prepare("SELECT id, title, blocked_by FROM tasks WHERE project_id = ? AND status = 'blocked'").all(resolved.id);
+      const recentDecisions = db2.prepare("SELECT id, title, decision, created_at FROM decisions WHERE project_id = ? ORDER BY created_at DESC LIMIT 5").all(resolved.id);
+      const taskCounts = db2.prepare("SELECT status, COUNT(*) as count FROM tasks WHERE project_id = ? GROUP BY status").all(resolved.id);
+      const contextItems = db2.prepare("SELECT key, value, category FROM context WHERE project_id = ? ORDER BY category, key").all(resolved.id);
+      db2.prepare("UPDATE projects SET status = status WHERE id = ?").run(resolved.id);
+      const result = {
+        project: projectRow,
+        last_session: lastSession ? {
+          summary: lastSession.summary,
+          next_steps: lastSession.next_steps,
+          when: lastSession.created_at
+        } : null,
+        task_summary: taskCounts,
+        active_tasks: activeTasks,
+        blocked_tasks: blockedTasks,
+        recent_decisions: recentDecisions,
+        context: contextItems
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "end_session",
+    {
+      title: "End Session",
+      description: "End a work session with a summary of what was accomplished and what to do next. Call this when the user is done working.",
+      inputSchema: {
+        project: z5.string().optional().describe("Project name or ID"),
+        summary: z5.string().describe("Summary of what was accomplished this session"),
+        tasks_worked_on: z5.array(z5.string()).optional().describe("Task IDs that were worked on"),
+        decisions_made: z5.array(z5.string()).optional().describe("Decision IDs that were made"),
+        next_steps: z5.string().optional().describe("What to do next time")
+      }
+    },
+    async ({ project, summary, tasks_worked_on, decisions_made, next_steps }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found." }], isError: true };
+      }
+      const db2 = getDb();
+      const id = generateId();
+      db2.prepare(
+        `INSERT INTO sessions (id, project_id, summary, tasks_worked_on, decisions_made, next_steps) VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(
+        id,
+        resolved.id,
+        summary,
+        tasks_worked_on ? JSON.stringify(tasks_worked_on) : null,
+        decisions_made ? JSON.stringify(decisions_made) : null,
+        next_steps ?? null
+      );
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ session_id: id, message: `Session ended for ${resolved.name}. Summary saved.` })
+        }]
+      };
+    }
+  );
+}
+
+// src/tools/queries.ts
+import { z as z6 } from "zod/v4";
+function registerQueryTools(server2) {
+  server2.registerTool(
+    "query",
+    {
+      title: "Query Database",
+      description: "Execute a read-only SQL query against the database. Only SELECT statements are allowed. Use this for custom queries not covered by other tools.",
+      inputSchema: {
+        sql: z6.string().describe("SQL SELECT query to execute")
+      }
+    },
+    async ({ sql }) => {
+      const trimmed = sql.trim();
+      if (!trimmed.toUpperCase().startsWith("SELECT")) {
+        return { content: [{ type: "text", text: "Only SELECT queries are allowed." }], isError: true };
+      }
+      const db2 = getDb();
+      try {
+        const stmt = db2.prepare(trimmed);
+        if (!stmt.reader) {
+          return { content: [{ type: "text", text: "Only read-only queries are allowed." }], isError: true };
+        }
+        const rows = stmt.all();
+        return {
+          content: [{ type: "text", text: JSON.stringify({ rows, count: rows.length }, null, 2) }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: `Query error: ${e.message}` }], isError: true };
+      }
+    }
+  );
+  server2.registerTool(
+    "get_project_summary",
+    {
+      title: "Get Project Summary",
+      description: "High-level summary of a project: total tasks by status, recent activity, open blockers, and upcoming priorities.",
+      inputSchema: {
+        project: z6.string().optional().describe("Project name or ID")
+      }
+    },
+    async ({ project }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found." }], isError: true };
+      }
+      const db2 = getDb();
+      const tasksByStatus = db2.prepare("SELECT status, COUNT(*) as count FROM tasks WHERE project_id = ? GROUP BY status").all(resolved.id);
+      const blockers = db2.prepare("SELECT id, title, blocked_by FROM tasks WHERE project_id = ? AND status = 'blocked'").all(resolved.id);
+      const upcomingPriorities = db2.prepare(
+        `SELECT id, title, priority, status FROM tasks
+           WHERE project_id = ? AND status IN ('todo', 'in_progress')
+           ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END
+           LIMIT 10`
+      ).all(resolved.id);
+      const recentActivity = db2.prepare(
+        `SELECT 'task' as type, title, updated_at FROM tasks WHERE project_id = ? AND updated_at > datetime('now', '-7 days')
+           UNION ALL
+           SELECT 'decision' as type, title, created_at as updated_at FROM decisions WHERE project_id = ? AND created_at > datetime('now', '-7 days')
+           UNION ALL
+           SELECT 'note' as type, substr(content, 1, 50) as title, created_at as updated_at FROM notes WHERE project_id = ? AND created_at > datetime('now', '-7 days')
+           ORDER BY updated_at DESC
+           LIMIT 20`
+      ).all(resolved.id, resolved.id, resolved.id);
+      const totalNotes = db2.prepare("SELECT COUNT(*) as count FROM notes WHERE project_id = ?").get(resolved.id);
+      const totalDecisions = db2.prepare("SELECT COUNT(*) as count FROM decisions WHERE project_id = ?").get(resolved.id);
+      const totalSessions = db2.prepare("SELECT COUNT(*) as count FROM sessions WHERE project_id = ?").get(resolved.id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(
+            {
+              project: resolved.name,
+              tasks_by_status: tasksByStatus,
+              blockers,
+              upcoming_priorities: upcomingPriorities,
+              recent_activity: recentActivity,
+              totals: { notes: totalNotes.count, decisions: totalDecisions.count, sessions: totalSessions.count }
+            },
+            null,
+            2
+          )
+        }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get_blockers",
+    {
+      title: "Get Blockers",
+      description: "List all blocked tasks with what's blocking them.",
+      inputSchema: {
+        project: z6.string().optional().describe("Project name or ID")
+      }
+    },
+    async ({ project }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found." }], isError: true };
+      }
+      const db2 = getDb();
+      const blockers = db2.prepare("SELECT * FROM tasks WHERE project_id = ? AND status = 'blocked'").all(resolved.id);
+      const enriched = blockers.map((task) => {
+        let blockingTasks = [];
+        if (task.blocked_by) {
+          try {
+            const ids = JSON.parse(task.blocked_by);
+            blockingTasks = ids.map((id) => {
+              const blocking = db2.prepare("SELECT id, title, status FROM tasks WHERE id = ?").get(id);
+              return blocking ?? { id, title: "Unknown task", status: "unknown" };
+            });
+          } catch {
+          }
+        }
+        return { ...task, blocking_tasks: blockingTasks };
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify({ project: resolved.name, blockers: enriched }, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "search",
+    {
+      title: "Search Everything",
+      description: "Full-text search across tasks, notes, and decisions for a project.",
+      inputSchema: {
+        project: z6.string().optional().describe("Project name or ID"),
+        query: z6.string().describe("Search query")
+      }
+    },
+    async ({ project, query }) => {
+      const resolved = resolveProjectOrDefault(project);
+      if (!resolved) {
+        return { content: [{ type: "text", text: project ? `Project "${project}" not found.` : "No active projects found." }], isError: true };
+      }
+      const db2 = getDb();
+      const pattern = `%${query}%`;
+      const tasks = db2.prepare("SELECT id, title, description, status, priority, 'task' as type FROM tasks WHERE project_id = ? AND (title LIKE ? OR description LIKE ?)").all(resolved.id, pattern, pattern);
+      const notes = db2.prepare("SELECT id, content, category, 'note' as type FROM notes WHERE project_id = ? AND content LIKE ?").all(resolved.id, pattern);
+      const decisions = db2.prepare("SELECT id, title, decision, reasoning, 'decision' as type FROM decisions WHERE project_id = ? AND (title LIKE ? OR decision LIKE ? OR reasoning LIKE ?)").all(resolved.id, pattern, pattern, pattern);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(
+            {
+              project: resolved.name,
+              query,
+              results: { tasks, notes, decisions },
+              total: tasks.length + notes.length + decisions.length
+            },
+            null,
+            2
+          )
+        }]
+      };
+    }
+  );
+}
+
+// src/index.ts
+var server = new McpServer(
+  {
+    name: "mindpm",
+    version: "1.0.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+registerProjectTools(server);
+registerTaskTools(server);
+registerDecisionTools(server);
+registerNoteTools(server);
+registerSessionTools(server);
+registerQueryTools(server);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  closeDb();
+  process.exit(1);
+});
+process.on("SIGINT", () => {
+  closeDb();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  closeDb();
+  process.exit(0);
+});