@cocaxcode/logbook-mcp 0.1.0

package/dist/server-5ZT2YKCQ.js

@@ -0,0 +1,958 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/topics.ts
+import { z } from "zod";
+
+// src/db/connection.ts
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/db/schema.ts
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS repos (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  path TEXT NOT NULL UNIQUE,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS topics (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  description TEXT,
+  commit_prefix TEXT,
+  is_custom INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS notes (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER REFERENCES repos(id) ON DELETE SET NULL,
+  topic_id INTEGER REFERENCES topics(id) ON DELETE SET NULL,
+  content TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS todos (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER REFERENCES repos(id) ON DELETE SET NULL,
+  topic_id INTEGER REFERENCES topics(id) ON DELETE SET NULL,
+  content TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  priority TEXT NOT NULL DEFAULT 'normal',
+  completed_at TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_notes_repo ON notes(repo_id);
+CREATE INDEX IF NOT EXISTS idx_notes_topic ON notes(topic_id);
+CREATE INDEX IF NOT EXISTS idx_notes_date ON notes(created_at);
+CREATE INDEX IF NOT EXISTS idx_todos_repo ON todos(repo_id);
+CREATE INDEX IF NOT EXISTS idx_todos_topic ON todos(topic_id);
+CREATE INDEX IF NOT EXISTS idx_todos_status ON todos(status);
+CREATE INDEX IF NOT EXISTS idx_todos_date ON todos(created_at);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
+  content,
+  content='notes',
+  content_rowid='id'
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS todos_fts USING fts5(
+  content,
+  content='todos',
+  content_rowid='id'
+);
+
+CREATE TRIGGER IF NOT EXISTS notes_ai AFTER INSERT ON notes BEGIN
+  INSERT INTO notes_fts(rowid, content) VALUES (new.id, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS notes_ad AFTER DELETE ON notes BEGIN
+  INSERT INTO notes_fts(notes_fts, rowid, content) VALUES ('delete', old.id, old.content);
+END;
+CREATE TRIGGER IF NOT EXISTS notes_au AFTER UPDATE ON notes BEGIN
+  INSERT INTO notes_fts(notes_fts, rowid, content) VALUES ('delete', old.id, old.content);
+  INSERT INTO notes_fts(rowid, content) VALUES (new.id, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS todos_ai AFTER INSERT ON todos BEGIN
+  INSERT INTO todos_fts(rowid, content) VALUES (new.id, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS todos_ad AFTER DELETE ON todos BEGIN
+  INSERT INTO todos_fts(todos_fts, rowid, content) VALUES ('delete', old.id, old.content);
+END;
+CREATE TRIGGER IF NOT EXISTS todos_au AFTER UPDATE ON todos BEGIN
+  INSERT INTO todos_fts(todos_fts, rowid, content) VALUES ('delete', old.id, old.content);
+  INSERT INTO todos_fts(rowid, content) VALUES (new.id, new.content);
+END;
+`;
+var SEED_TOPICS_SQL = `
+INSERT OR IGNORE INTO topics (name, description, commit_prefix, is_custom) VALUES
+  ('feature', 'Funcionalidad nueva', 'feat', 0),
+  ('fix', 'Correcci\xF3n de errores', 'fix', 0),
+  ('chore', 'Mantenimiento general', 'refactor,docs,ci,build,chore,test,perf', 0),
+  ('idea', 'Ideas y propuestas futuras', NULL, 0),
+  ('decision', 'Decisiones tomadas', NULL, 0),
+  ('blocker', 'Bloqueos activos', NULL, 0);
+`;
+
+// src/db/connection.ts
+var DB_DIR = join(homedir(), ".logbook");
+var DB_PATH = join(DB_DIR, "logbook.db");
+var db = null;
+function getDb(dbPath) {
+  if (db) return db;
+  const path = dbPath ?? DB_PATH;
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(SCHEMA_SQL);
+  db.exec(SEED_TOPICS_SQL);
+  return db;
+}
+
+// src/db/queries.ts
+function insertRepo(db2, name, path) {
+  const stmt = db2.prepare(
+    "INSERT INTO repos (name, path) VALUES (?, ?)"
+  );
+  const result = stmt.run(name, path);
+  return db2.prepare("SELECT * FROM repos WHERE id = ?").get(result.lastInsertRowid);
+}
+function getRepoByPath(db2, path) {
+  return db2.prepare("SELECT * FROM repos WHERE path = ?").get(path);
+}
+function getTopicByName(db2, name) {
+  return db2.prepare("SELECT * FROM topics WHERE name = ?").get(name);
+}
+function getAllTopics(db2) {
+  return db2.prepare("SELECT * FROM topics ORDER BY is_custom, name").all();
+}
+function insertTopic(db2, name, description) {
+  const stmt = db2.prepare(
+    "INSERT INTO topics (name, description, is_custom) VALUES (?, ?, 1)"
+  );
+  const result = stmt.run(name, description ?? null);
+  return db2.prepare("SELECT * FROM topics WHERE id = ?").get(result.lastInsertRowid);
+}
+var NOTE_WITH_META_SQL = `
+  SELECT n.*, r.name as repo_name, t.name as topic_name
+  FROM notes n
+  LEFT JOIN repos r ON n.repo_id = r.id
+  LEFT JOIN topics t ON n.topic_id = t.id
+`;
+function insertNote(db2, repoId, topicId, content) {
+  const stmt = db2.prepare(
+    "INSERT INTO notes (repo_id, topic_id, content) VALUES (?, ?, ?)"
+  );
+  const result = stmt.run(repoId, topicId, content);
+  return db2.prepare(`${NOTE_WITH_META_SQL} WHERE n.id = ?`).get(result.lastInsertRowid);
+}
+function getNotes(db2, filters = {}) {
+  const conditions = [];
+  const params = [];
+  if (filters.repoId !== void 0) {
+    conditions.push("n.repo_id = ?");
+    params.push(filters.repoId);
+  }
+  if (filters.topicId !== void 0) {
+    conditions.push("n.topic_id = ?");
+    params.push(filters.topicId);
+  }
+  if (filters.from) {
+    conditions.push("n.created_at >= ?");
+    params.push(filters.from);
+  }
+  if (filters.to) {
+    conditions.push("n.created_at < ?");
+    params.push(filters.to);
+  }
+  const where = conditions.length ? ` WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filters.limit ?? 100;
+  return db2.prepare(
+    `${NOTE_WITH_META_SQL}${where} ORDER BY n.created_at DESC LIMIT ?`
+  ).all(...params, limit);
+}
+var TODO_WITH_META_SQL = `
+  SELECT t.*, r.name as repo_name, tp.name as topic_name, 'manual' as source
+  FROM todos t
+  LEFT JOIN repos r ON t.repo_id = r.id
+  LEFT JOIN topics tp ON t.topic_id = tp.id
+`;
+function insertTodo(db2, repoId, topicId, content, priority = "normal") {
+  const stmt = db2.prepare(
+    "INSERT INTO todos (repo_id, topic_id, content, priority) VALUES (?, ?, ?, ?)"
+  );
+  const result = stmt.run(repoId, topicId, content, priority);
+  return db2.prepare(`${TODO_WITH_META_SQL} WHERE t.id = ?`).get(result.lastInsertRowid);
+}
+function getTodos(db2, filters = {}) {
+  const conditions = [];
+  const params = [];
+  if (filters.status && filters.status !== "all") {
+    conditions.push("t.status = ?");
+    params.push(filters.status);
+  }
+  if (filters.repoId !== void 0) {
+    conditions.push("t.repo_id = ?");
+    params.push(filters.repoId);
+  }
+  if (filters.topicId !== void 0) {
+    conditions.push("t.topic_id = ?");
+    params.push(filters.topicId);
+  }
+  if (filters.priority) {
+    conditions.push("t.priority = ?");
+    params.push(filters.priority);
+  }
+  if (filters.from) {
+    conditions.push("t.created_at >= ?");
+    params.push(filters.from);
+  }
+  if (filters.to) {
+    conditions.push("t.created_at < ?");
+    params.push(filters.to);
+  }
+  const where = conditions.length ? ` WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filters.limit ?? 100;
+  return db2.prepare(
+    `${TODO_WITH_META_SQL}${where} ORDER BY t.created_at DESC LIMIT ?`
+  ).all(...params, limit);
+}
+function updateTodoStatus(db2, ids, status) {
+  const completedAt = status === "done" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+  const placeholders = ids.map(() => "?").join(",");
+  db2.prepare(
+    `UPDATE todos SET status = ?, completed_at = ? WHERE id IN (${placeholders})`
+  ).run(status, completedAt, ...ids);
+  return db2.prepare(
+    `${TODO_WITH_META_SQL} WHERE t.id IN (${placeholders})`
+  ).all(...ids);
+}
+function updateTodo(db2, id, fields) {
+  const sets = [];
+  const params = [];
+  if (fields.content !== void 0) {
+    sets.push("content = ?");
+    params.push(fields.content);
+  }
+  if (fields.topicId !== void 0) {
+    sets.push("topic_id = ?");
+    params.push(fields.topicId);
+  }
+  if (fields.priority !== void 0) {
+    sets.push("priority = ?");
+    params.push(fields.priority);
+  }
+  if (sets.length === 0) return void 0;
+  params.push(id);
+  db2.prepare(`UPDATE todos SET ${sets.join(", ")} WHERE id = ?`).run(
+    ...params
+  );
+  return db2.prepare(`${TODO_WITH_META_SQL} WHERE t.id = ?`).get(id);
+}
+function deleteTodos(db2, ids) {
+  const placeholders = ids.map(() => "?").join(",");
+  const existing = db2.prepare(`SELECT id FROM todos WHERE id IN (${placeholders})`).all(...ids);
+  const existingIds = existing.map((r) => r.id);
+  if (existingIds.length > 0) {
+    const ep = existingIds.map(() => "?").join(",");
+    db2.prepare(`DELETE FROM todos WHERE id IN (${ep})`).run(
+      ...existingIds
+    );
+  }
+  return existingIds;
+}
+function searchNotes(db2, query, filters = {}) {
+  const conditions = ["notes_fts MATCH ?"];
+  const params = [sanitizeFts(query)];
+  if (filters.repoId !== void 0) {
+    conditions.push("n.repo_id = ?");
+    params.push(filters.repoId);
+  }
+  if (filters.topicId !== void 0) {
+    conditions.push("n.topic_id = ?");
+    params.push(filters.topicId);
+  }
+  const limit = filters.limit ?? 20;
+  const where = conditions.join(" AND ");
+  return db2.prepare(
+    `SELECT n.*, r.name as repo_name, t.name as topic_name, rank
+       FROM notes_fts
+       JOIN notes n ON n.id = notes_fts.rowid
+       LEFT JOIN repos r ON n.repo_id = r.id
+       LEFT JOIN topics t ON n.topic_id = t.id
+       WHERE ${where}
+       ORDER BY rank
+       LIMIT ?`
+  ).all(...params, limit);
+}
+function searchTodos(db2, query, filters = {}) {
+  const conditions = ["todos_fts MATCH ?"];
+  const params = [sanitizeFts(query)];
+  if (filters.repoId !== void 0) {
+    conditions.push("t.repo_id = ?");
+    params.push(filters.repoId);
+  }
+  if (filters.topicId !== void 0) {
+    conditions.push("t.topic_id = ?");
+    params.push(filters.topicId);
+  }
+  const limit = filters.limit ?? 20;
+  const where = conditions.join(" AND ");
+  return db2.prepare(
+    `SELECT t.*, r.name as repo_name, tp.name as topic_name, 'manual' as source, rank
+       FROM todos_fts
+       JOIN todos t ON t.id = todos_fts.rowid
+       LEFT JOIN repos r ON t.repo_id = r.id
+       LEFT JOIN topics tp ON t.topic_id = tp.id
+       WHERE ${where}
+       ORDER BY rank
+       LIMIT ?`
+  ).all(...params, limit);
+}
+function getCompletedTodos(db2, filters = {}) {
+  const conditions = ["t.status = 'done'"];
+  const params = [];
+  if (filters.repoId !== void 0) {
+    conditions.push("t.repo_id = ?");
+    params.push(filters.repoId);
+  }
+  if (filters.topicId !== void 0) {
+    conditions.push("t.topic_id = ?");
+    params.push(filters.topicId);
+  }
+  if (filters.from) {
+    conditions.push("t.completed_at >= ?");
+    params.push(filters.from);
+  }
+  if (filters.to) {
+    conditions.push("t.completed_at < ?");
+    params.push(filters.to);
+  }
+  const where = conditions.join(" AND ");
+  return db2.prepare(
+    `${TODO_WITH_META_SQL} WHERE ${where} ORDER BY t.completed_at DESC`
+  ).all(...params);
+}
+function sanitizeFts(query) {
+  return query.split(/\s+/).filter(Boolean).map((word) => `"${word.replace(/"/g, "")}"`).join(" ");
+}
+
+// src/tools/topics.ts
+function registerTopicsTool(server) {
+  server.tool(
+    "logbook_topics",
+    "Lista o crea temas para organizar notas y TODOs. Temas predefinidos: feature, fix, chore, idea, decision, blocker.",
+    {
+      action: z.enum(["list", "add"]).default("list").describe("Accion: list (ver temas) o add (crear tema custom)"),
+      name: z.string().optional().describe("Nombre del nuevo tema (solo para action=add, lowercase, sin espacios)"),
+      description: z.string().optional().describe("Descripcion del nuevo tema (solo para action=add)")
+    },
+    async ({ action, name, description }) => {
+      try {
+        const db2 = getDb();
+        if (action === "add") {
+          if (!name) {
+            return {
+              isError: true,
+              content: [{ type: "text", text: 'El parametro "name" es obligatorio para action=add' }]
+            };
+          }
+          const normalized = name.toLowerCase().replace(/\s+/g, "-");
+          const topic = insertTopic(db2, normalized, description);
+          return {
+            content: [{ type: "text", text: JSON.stringify(topic) }]
+          };
+        }
+        const topics = getAllTopics(db2);
+        return {
+          content: [{ type: "text", text: JSON.stringify(topics) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/note.ts
+import { z as z2 } from "zod";
+
+// src/git/detect-repo.ts
+import { execSync } from "child_process";
+import { basename } from "path";
+function detectRepoPath() {
+  try {
+    const result = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim().replace(/\\/g, "/");
+  } catch {
+    return null;
+  }
+}
+function autoRegisterRepo(db2) {
+  const repoPath = detectRepoPath();
+  if (!repoPath) return null;
+  const existing = getRepoByPath(db2, repoPath);
+  if (existing) return existing;
+  const name = basename(repoPath);
+  return insertRepo(db2, name, repoPath);
+}
+
+// src/tools/note.ts
+function registerNoteTool(server) {
+  server.tool(
+    "logbook_note",
+    "A\xF1ade una nota al logbook. Topics: feature, fix, chore, idea, decision, blocker. Si no se pasa topic, queda sin categorizar.",
+    {
+      content: z2.string().describe("Contenido de la nota"),
+      topic: z2.string().optional().describe("Topic: feature, fix, chore, idea, decision, blocker (o custom)")
+    },
+    async ({ content, topic }) => {
+      try {
+        const db2 = getDb();
+        const repo = autoRegisterRepo(db2);
+        let topicId = null;
+        if (topic) {
+          const topicRow = getTopicByName(db2, topic);
+          if (!topicRow) {
+            const available = getAllTopics(db2);
+            return {
+              isError: true,
+              content: [{
+                type: "text",
+                text: `Topic "${topic}" no existe. Disponibles: ${available.map((t) => t.name).join(", ")}`
+              }]
+            };
+          }
+          topicId = topicRow.id;
+        }
+        const note = insertNote(db2, repo?.id ?? null, topicId, content);
+        return {
+          content: [{ type: "text", text: JSON.stringify(note) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error creando nota: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/todo-add.ts
+import { z as z3 } from "zod";
+var priorityEnum = z3.enum(["low", "normal", "high", "urgent"]);
+function registerTodoAddTool(server) {
+  server.tool(
+    "logbook_todo_add",
+    "Crea uno o varios TODOs. Para uno solo usa content. Para varios usa items (array). El topic se puede pasar o dejar que la AI lo infiera.",
+    {
+      content: z3.string().optional().describe("Contenido del TODO (para crear uno solo)"),
+      topic: z3.string().optional().describe("Topic para el TODO individual"),
+      priority: priorityEnum.optional().default("normal").describe("Prioridad del TODO individual"),
+      items: z3.array(
+        z3.object({
+          content: z3.string().describe("Contenido del TODO"),
+          topic: z3.string().optional().describe("Topic"),
+          priority: priorityEnum.optional().default("normal").describe("Prioridad")
+        })
+      ).optional().describe("Array de TODOs para crear varios a la vez")
+    },
+    async ({ content, topic, priority, items }) => {
+      try {
+        if (!content && (!items || items.length === 0)) {
+          return {
+            isError: true,
+            content: [{
+              type: "text",
+              text: 'Debes pasar "content" (para uno) o "items" (para varios)'
+            }]
+          };
+        }
+        const db2 = getDb();
+        const repo = autoRegisterRepo(db2);
+        const repoId = repo?.id ?? null;
+        const todoItems = items ? items : [{ content, topic, priority: priority ?? "normal" }];
+        const results = [];
+        for (const item of todoItems) {
+          let topicId = null;
+          if (item.topic) {
+            const topicRow = getTopicByName(db2, item.topic);
+            if (!topicRow) {
+              const available = getAllTopics(db2);
+              return {
+                isError: true,
+                content: [{
+                  type: "text",
+                  text: `Topic "${item.topic}" no existe. Disponibles: ${available.map((t) => t.name).join(", ")}`
+                }]
+              };
+            }
+            topicId = topicRow.id;
+          }
+          const todo = insertTodo(
+            db2,
+            repoId,
+            topicId,
+            item.content,
+            item.priority ?? "normal"
+          );
+          results.push(todo);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(
+              results.length === 1 ? results[0] : { created: results.length, todos: results }
+            )
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error creando TODO: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/todo-list.ts
+import { z as z4 } from "zod";
+
+// src/git/code-todos.ts
+import { execSync as execSync2 } from "child_process";
+var TAG_TO_TOPIC = {
+  TODO: "feature",
+  FIXME: "fix",
+  BUG: "fix",
+  HACK: "chore"
+};
+function scanCodeTodos(repoPath) {
+  try {
+    const output = execSync2(
+      `git -C "${repoPath}" grep -n -E "(TODO|FIXME|HACK|BUG):" --no-color`,
+      { encoding: "utf-8", timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return parseGitGrepOutput(output);
+  } catch {
+    return [];
+  }
+}
+function parseGitGrepOutput(output) {
+  if (!output.trim()) return [];
+  const regex = /^(.+?):(\d+):.*?\b(TODO|FIXME|HACK|BUG):\s*(.+)$/;
+  return output.trim().split("\n").filter(Boolean).map((line) => {
+    const match = line.match(regex);
+    if (!match) return null;
+    const [, file, lineNum, tag, content] = match;
+    return {
+      content: content.trim(),
+      source: "code",
+      file,
+      line: parseInt(lineNum, 10),
+      tag,
+      topic_name: TAG_TO_TOPIC[tag] ?? "chore"
+    };
+  }).filter((item) => item !== null);
+}
+
+// src/tools/todo-list.ts
+function registerTodoListTool(server) {
+  server.tool(
+    "logbook_todo_list",
+    "Lista TODOs agrupados por topic. Incluye TODOs manuales y del codigo (TODO/FIXME/HACK/BUG). Por defecto muestra pendientes del proyecto actual.",
+    {
+      status: z4.enum(["pending", "done", "all"]).optional().default("pending").describe("Filtrar por estado (default: pending)"),
+      topic: z4.string().optional().describe("Filtrar por topic"),
+      priority: z4.enum(["low", "normal", "high", "urgent"]).optional().describe("Filtrar por prioridad"),
+      source: z4.enum(["all", "manual", "code"]).optional().default("all").describe("Filtrar por origen: manual (DB), code (git grep), all"),
+      scope: z4.enum(["project", "global"]).optional().default("project").describe("Scope: project (auto-detecta) o global (todos los proyectos)"),
+      from: z4.string().optional().describe("Desde fecha (YYYY-MM-DD)"),
+      to: z4.string().optional().describe("Hasta fecha (YYYY-MM-DD)"),
+      limit: z4.number().optional().default(100).describe("Maximo resultados manuales")
+    },
+    async ({ status, topic, priority, source, scope, from, to, limit }) => {
+      try {
+        const db2 = getDb();
+        const repo = scope === "project" ? autoRegisterRepo(db2) : null;
+        let topicId;
+        if (topic) {
+          const topicRow = getTopicByName(db2, topic);
+          if (topicRow) topicId = topicRow.id;
+        }
+        const manualTodos = source === "code" ? [] : getTodos(db2, {
+          status,
+          repoId: repo?.id,
+          topicId,
+          priority,
+          from,
+          to,
+          limit
+        });
+        let codeTodos = [];
+        if (source !== "manual" && status !== "done") {
+          const repoPath = scope === "project" ? detectRepoPath() : null;
+          if (repoPath) {
+            codeTodos = scanCodeTodos(repoPath);
+            if (topic) {
+              codeTodos = codeTodos.filter((ct) => ct.topic_name === topic);
+            }
+          }
+        }
+        const groupMap = /* @__PURE__ */ new Map();
+        for (const todo of manualTodos) {
+          const key = todo.topic_name ?? "sin-topic";
+          if (!groupMap.has(key)) groupMap.set(key, []);
+          groupMap.get(key).push(todo);
+        }
+        for (const ct of codeTodos) {
+          const key = ct.topic_name;
+          if (!groupMap.has(key)) groupMap.set(key, []);
+          groupMap.get(key).push(ct);
+        }
+        const groups = Array.from(groupMap.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([topicName, items]) => ({ topic: topicName, items }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              groups,
+              summary: {
+                manual: manualTodos.length,
+                code: codeTodos.length,
+                total: manualTodos.length + codeTodos.length
+              }
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error listando TODOs: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/todo-done.ts
+import { z as z5 } from "zod";
+function registerTodoDoneTool(server) {
+  server.tool(
+    "logbook_todo_done",
+    "Marca TODOs como hechos o los devuelve a pendiente (undo). Acepta uno o varios IDs.",
+    {
+      ids: z5.union([z5.number(), z5.array(z5.number())]).describe("ID o array de IDs de TODOs a marcar"),
+      undo: z5.boolean().optional().default(false).describe("Si true, devuelve a pendiente en vez de marcar como hecho")
+    },
+    async ({ ids, undo }) => {
+      try {
+        const db2 = getDb();
+        const idArray = Array.isArray(ids) ? ids : [ids];
+        const status = undo ? "pending" : "done";
+        const updated = updateTodoStatus(db2, idArray, status);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              action: undo ? "undo" : "done",
+              updated: updated.length,
+              todos: updated
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/todo-edit.ts
+import { z as z6 } from "zod";
+function registerTodoEditTool(server) {
+  server.tool(
+    "logbook_todo_edit",
+    "Edita un TODO existente: contenido, topic o prioridad.",
+    {
+      id: z6.number().describe("ID del TODO a editar"),
+      content: z6.string().optional().describe("Nuevo contenido"),
+      topic: z6.string().optional().describe("Nuevo topic"),
+      priority: z6.enum(["low", "normal", "high", "urgent"]).optional().describe("Nueva prioridad")
+    },
+    async ({ id, content, topic, priority }) => {
+      try {
+        const db2 = getDb();
+        let topicId;
+        if (topic) {
+          const topicRow = getTopicByName(db2, topic);
+          if (!topicRow) {
+            const available = getAllTopics(db2);
+            return {
+              isError: true,
+              content: [{
+                type: "text",
+                text: `Topic "${topic}" no existe. Disponibles: ${available.map((t) => t.name).join(", ")}`
+              }]
+            };
+          }
+          topicId = topicRow.id;
+        }
+        const updated = updateTodo(db2, id, { content, topicId, priority });
+        if (!updated) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `TODO #${id} no encontrado o sin cambios` }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(updated) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error editando TODO: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/todo-rm.ts
+import { z as z7 } from "zod";
+function registerTodoRmTool(server) {
+  server.tool(
+    "logbook_todo_rm",
+    "Elimina TODOs por ID. Acepta uno o varios IDs.",
+    {
+      ids: z7.union([z7.number(), z7.array(z7.number())]).describe("ID o array de IDs de TODOs a eliminar")
+    },
+    async ({ ids }) => {
+      try {
+        const db2 = getDb();
+        const idArray = Array.isArray(ids) ? ids : [ids];
+        const deleted = deleteTodos(db2, idArray);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              deleted: deleted.length,
+              ids: deleted
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error eliminando TODOs: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/log.ts
+import { z as z8 } from "zod";
+function registerLogTool(server) {
+  server.tool(
+    "logbook_log",
+    "Muestra actividad: notas y TODOs completados para un periodo. Por defecto muestra el dia de hoy del proyecto actual.",
+    {
+      period: z8.enum(["today", "yesterday", "week", "month"]).optional().describe("Periodo predefinido (default: today)"),
+      from: z8.string().optional().describe("Desde fecha (YYYY-MM-DD). Sobreescribe period."),
+      to: z8.string().optional().describe("Hasta fecha (YYYY-MM-DD). Sobreescribe period."),
+      type: z8.enum(["all", "notes", "todos"]).optional().default("all").describe("Filtrar por tipo: all, notes, todos"),
+      topic: z8.string().optional().describe("Filtrar por topic"),
+      scope: z8.enum(["project", "global"]).optional().default("project").describe("Scope: project (auto-detecta) o global")
+    },
+    async ({ period, from, to, type, topic, scope }) => {
+      try {
+        const db2 = getDb();
+        const repo = scope === "project" ? autoRegisterRepo(db2) : null;
+        const { dateFrom, dateTo } = resolveDates(period, from, to);
+        let topicId;
+        if (topic) {
+          const topicRow = getTopicByName(db2, topic);
+          if (topicRow) topicId = topicRow.id;
+        }
+        const filters = {
+          repoId: repo?.id,
+          topicId,
+          from: dateFrom,
+          to: dateTo
+        };
+        const notes = type === "todos" ? [] : getNotes(db2, filters);
+        const completedTodos = type === "notes" ? [] : getCompletedTodos(db2, filters);
+        const entries = [
+          ...notes.map((n) => ({
+            type: "note",
+            data: n,
+            timestamp: n.created_at
+          })),
+          ...completedTodos.map((t) => ({
+            type: "todo",
+            data: t,
+            timestamp: t.completed_at ?? t.created_at
+          }))
+        ].sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              period: from ? `${dateFrom} \u2014 ${dateTo}` : period ?? "today",
+              scope: scope ?? "project",
+              project: repo?.name ?? null,
+              entries,
+              summary: {
+                notes: notes.length,
+                todos_completed: completedTodos.length,
+                total: entries.length
+              }
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+function resolveDates(period, from, to) {
+  if (from) {
+    const dateTo = to ?? new Date(Date.now() + 864e5).toISOString().split("T")[0];
+    return { dateFrom: from, dateTo };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const today = now.toISOString().split("T")[0];
+  const tomorrow = new Date(now.getTime() + 864e5).toISOString().split("T")[0];
+  switch (period) {
+    case "yesterday": {
+      const yesterday = new Date(now.getTime() - 864e5).toISOString().split("T")[0];
+      return { dateFrom: yesterday, dateTo: today };
+    }
+    case "week": {
+      const weekAgo = new Date(now.getTime() - 7 * 864e5).toISOString().split("T")[0];
+      return { dateFrom: weekAgo, dateTo: tomorrow };
+    }
+    case "month": {
+      const monthAgo = new Date(now.getTime() - 30 * 864e5).toISOString().split("T")[0];
+      return { dateFrom: monthAgo, dateTo: tomorrow };
+    }
+    default:
+      return { dateFrom: today, dateTo: tomorrow };
+  }
+}
+
+// src/tools/search.ts
+import { z as z9 } from "zod";
+function registerSearchTool(server) {
+  server.tool(
+    "logbook_search",
+    "Busqueda full-text en notas y TODOs. Usa FTS5 para busqueda rapida.",
+    {
+      query: z9.string().describe("Texto a buscar"),
+      type: z9.enum(["all", "notes", "todos"]).optional().default("all").describe("Buscar en: all, notes, todos"),
+      topic: z9.string().optional().describe("Filtrar por topic"),
+      scope: z9.enum(["project", "global"]).optional().default("project").describe("Scope: project o global"),
+      limit: z9.number().optional().default(20).describe("Maximo resultados (default: 20)")
+    },
+    async ({ query, type, topic, scope, limit }) => {
+      try {
+        const db2 = getDb();
+        const repo = scope === "project" ? autoRegisterRepo(db2) : null;
+        let topicId;
+        if (topic) {
+          const topicRow = getTopicByName(db2, topic);
+          if (topicRow) topicId = topicRow.id;
+        }
+        const filters = {
+          repoId: repo?.id,
+          topicId,
+          limit
+        };
+        const results = [];
+        if (type !== "todos") {
+          const notes = searchNotes(db2, query, filters);
+          results.push(
+            ...notes.map((n, i) => ({
+              type: "note",
+              data: n,
+              rank: i
+            }))
+          );
+        }
+        if (type !== "notes") {
+          const todos = searchTodos(db2, query, filters);
+          results.push(
+            ...todos.map((t, i) => ({
+              type: "todo",
+              data: t,
+              rank: i
+            }))
+          );
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              query,
+              results,
+              total: results.length
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error buscando: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/server.ts
+var VERSION = true ? "0.1.0" : "0.0.0";
+function createServer() {
+  const server = new McpServer({
+    name: "logbook-mcp",
+    version: VERSION
+  });
+  registerTopicsTool(server);
+  registerNoteTool(server);
+  registerTodoAddTool(server);
+  registerTodoListTool(server);
+  registerTodoDoneTool(server);
+  registerTodoEditTool(server);
+  registerTodoRmTool(server);
+  registerLogTool(server);
+  registerSearchTool(server);
+  return server;
+}
+export {
+  createServer
+};