@cocaxcode/logbook-mcp 0.5.0 → 0.5.1

package/dist/server-H4RARRWW.js

@@ -0,0 +1,2773 @@
+#!/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',
+  remind_at TEXT,
+  remind_pattern TEXT,
+  remind_last_done TEXT,
+  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 TABLE IF NOT EXISTS code_todo_snapshots (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  file TEXT NOT NULL,
+  line INTEGER NOT NULL,
+  tag TEXT NOT NULL,
+  content TEXT NOT NULL,
+  topic_name TEXT NOT NULL,
+  first_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+  resolved_at TEXT,
+  UNIQUE(repo_id, file, content)
+);
+
+CREATE INDEX IF NOT EXISTS idx_code_snapshots_repo ON code_todo_snapshots(repo_id);
+CREATE INDEX IF NOT EXISTS idx_code_snapshots_resolved ON code_todo_snapshots(resolved_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 MIGRATIONS_SQL = `
+-- Add reminder columns to existing todos tables (safe to run multiple times)
+ALTER TABLE todos ADD COLUMN remind_at TEXT;
+ALTER TABLE todos ADD COLUMN remind_pattern TEXT;
+ALTER TABLE todos ADD COLUMN remind_last_done TEXT;
+`;
+var POST_MIGRATION_SQL = `
+CREATE INDEX IF NOT EXISTS idx_todos_remind ON todos(remind_at);
+`;
+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),
+  ('reminder', 'Recordatorios con fecha', 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);
+  for (const stmt of MIGRATIONS_SQL.split(";").map((s) => s.trim()).filter(Boolean)) {
+    try {
+      db.exec(stmt);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (!msg.includes("duplicate column")) {
+        console.error(`Migration warning: ${msg}`);
+      }
+    }
+  }
+  db.exec(POST_MIGRATION_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 getRepoByName(db2, name) {
+  return db2.prepare("SELECT * FROM repos WHERE name = ?").get(name);
+}
+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", remindAt, remindPattern) {
+  const stmt = db2.prepare(
+    "INSERT INTO todos (repo_id, topic_id, content, priority, remind_at, remind_pattern) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  const result = stmt.run(repoId, topicId, content, priority, remindAt ?? null, remindPattern ?? null);
+  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) {
+  if (ids.length === 0) return [];
+  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) {
+  if (ids.length === 0) return [];
+  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 getDueReminders(db2) {
+  const now = /* @__PURE__ */ new Date();
+  const today = now.toISOString().split("T")[0];
+  const tomorrow = new Date(now.getTime() + 864e5).toISOString().split("T")[0];
+  const todayItems = db2.prepare(
+    `${TODO_WITH_META_SQL} WHERE t.status = 'pending' AND t.remind_at >= ? AND t.remind_at < ? ORDER BY t.remind_at`
+  ).all(today, tomorrow);
+  const overdueItems = db2.prepare(
+    `${TODO_WITH_META_SQL} WHERE t.status = 'pending' AND t.remind_at IS NOT NULL AND t.remind_at < ? AND t.remind_pattern IS NULL ORDER BY t.remind_at`
+  ).all(today);
+  const recurringAll = db2.prepare(
+    `${TODO_WITH_META_SQL} WHERE t.remind_pattern IS NOT NULL AND (t.remind_last_done IS NULL OR t.remind_last_done < ?)`
+  ).all(today);
+  const recurringToday = recurringAll.filter((r) => matchesPattern(r.remind_pattern, now));
+  const hasAny = todayItems.length > 0 || overdueItems.length > 0 || recurringToday.length > 0;
+  if (!hasAny) return null;
+  return {
+    today: groupByRepo(todayItems),
+    overdue: groupByRepo(overdueItems),
+    recurring: groupByRepo(recurringToday)
+  };
+}
+function ackRecurringReminder(db2, id) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  db2.prepare("UPDATE todos SET remind_last_done = ? WHERE id = ?").run(today, id);
+}
+function matchesPattern(pattern, date) {
+  const dayOfWeek = date.getDay();
+  const dayOfMonth = date.getDate();
+  if (pattern === "daily") return true;
+  if (pattern === "weekdays") return dayOfWeek >= 1 && dayOfWeek <= 5;
+  if (pattern.startsWith("weekly:")) {
+    const days = pattern.slice(7).split(",").map(Number);
+    return days.some((d) => d % 7 === dayOfWeek);
+  }
+  if (pattern.startsWith("monthly:")) {
+    const days = pattern.slice(8).split(",").map(Number);
+    return days.includes(dayOfMonth);
+  }
+  return false;
+}
+function groupByRepo(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = item.repo_name ?? "global";
+    if (!map.has(key)) map.set(key, []);
+    map.get(key).push(item);
+  }
+  return Array.from(map.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([repo_name, reminders]) => ({
+    repo_name: repo_name === "global" ? null : repo_name,
+    reminders
+  }));
+}
+function resolveTopicId(db2, name) {
+  const existing = getTopicByName(db2, name);
+  if (existing) return existing.id;
+  const normalized = name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  if (!normalized) return getTopicByName(db2, "chore").id;
+  const existingNorm = getTopicByName(db2, normalized);
+  if (existingNorm) return existingNorm.id;
+  const created = insertTopic(db2, normalized);
+  return created.id;
+}
+function syncCodeTodos(db2, repoId, currentTodos) {
+  const sync = db2.transaction(() => {
+    const existing = db2.prepare("SELECT * FROM code_todo_snapshots WHERE repo_id = ? AND resolved_at IS NULL").all(repoId);
+    const currentSet = new Set(currentTodos.map((t) => `${t.file}::${t.content}`));
+    let resolved = 0;
+    for (const snap of existing) {
+      const key = `${snap.file}::${snap.content}`;
+      if (!currentSet.has(key)) {
+        db2.prepare("UPDATE code_todo_snapshots SET resolved_at = datetime('now') WHERE id = ?").run(snap.id);
+        resolved++;
+      }
+    }
+    const existingSet = new Set(existing.map((s) => `${s.file}::${s.content}`));
+    const allSnapshots = db2.prepare("SELECT file, content FROM code_todo_snapshots WHERE repo_id = ?").all(repoId);
+    const allSet = new Set(allSnapshots.map((s) => `${s.file}::${s.content}`));
+    let added = 0;
+    for (const todo of currentTodos) {
+      const key = `${todo.file}::${todo.content}`;
+      if (!allSet.has(key)) {
+        db2.prepare(
+          "INSERT INTO code_todo_snapshots (repo_id, file, line, tag, content, topic_name) VALUES (?, ?, ?, ?, ?, ?)"
+        ).run(repoId, todo.file, todo.line, todo.tag, todo.content, todo.topic_name);
+        added++;
+      } else if (existingSet.has(key)) {
+        db2.prepare("UPDATE code_todo_snapshots SET line = ? WHERE repo_id = ? AND file = ? AND content = ? AND resolved_at IS NULL").run(todo.line, repoId, todo.file, todo.content);
+      }
+    }
+    return { added, resolved };
+  });
+  return sync();
+}
+function getResolvedCodeTodos(db2, repoId, from, to) {
+  const conditions = ["repo_id = ?", "resolved_at IS NOT NULL"];
+  const params = [repoId];
+  if (from) {
+    conditions.push("resolved_at >= ?");
+    params.push(from);
+  }
+  if (to) {
+    conditions.push("resolved_at < ?");
+    params.push(to);
+  }
+  return db2.prepare(`SELECT * FROM code_todo_snapshots WHERE ${conditions.join(" AND ")} ORDER BY resolved_at DESC`).all(...params);
+}
+function sanitizeFts(query) {
+  const words = query.replace(/\0/g, "").split(/\s+/).filter(Boolean).map((word) => word.replace(/"/g, "")).filter(Boolean);
+  if (words.length === 0) return '""';
+  return words.map((word) => `"${word}"`).join(" ");
+}
+
+// src/git/detect-repo.ts
+import { execFileSync } from "child_process";
+import { basename } from "path";
+function detectRepoPath() {
+  try {
+    const result = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim().replace(/\\/g, "/");
+  } catch {
+    return null;
+  }
+}
+
+// src/git/code-todos.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var TAG_TO_TOPIC = {
+  TODO: "feature",
+  FIXME: "fix",
+  BUG: "fix",
+  HACK: "chore"
+};
+function scanCodeTodos(repoPath) {
+  try {
+    const output = execFileSync2(
+      "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/storage/sqlite/index.ts
+import { basename as basename2 } from "path";
+function toEntryId(id) {
+  return String(id);
+}
+function toNumericId(id) {
+  return Number(id);
+}
+function detectWorkspaceFromPath(repoPath) {
+  if (!repoPath) {
+    return {
+      workspace: process.env.LOGBOOK_WORKSPACE || "default",
+      project: "global"
+    };
+  }
+  const normalized = repoPath.replace(/\\/g, "/");
+  const project = basename2(normalized);
+  const projectsIdx = normalized.toLowerCase().indexOf("/projects/");
+  if (projectsIdx !== -1) {
+    const before = normalized.slice(0, projectsIdx);
+    const workspace2 = basename2(before);
+    return { workspace: workspace2, project };
+  }
+  const parts = normalized.split("/");
+  const workspace = parts.length >= 2 ? parts[parts.length - 2] : process.env.LOGBOOK_WORKSPACE || "default";
+  return { workspace, project };
+}
+function todayDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+var SqliteStorage = class {
+  repoPath = null;
+  repoId = null;
+  // ── Repos ──
+  autoRegisterRepo() {
+    const db2 = getDb();
+    this.repoPath = detectRepoPath();
+    if (!this.repoPath) return null;
+    const existing = getRepoByPath(db2, this.repoPath);
+    if (existing) {
+      this.repoId = existing.id;
+      return { id: toEntryId(existing.id), name: existing.name, path: existing.path };
+    }
+    let name = basename2(this.repoPath);
+    const nameConflict = getRepoByName(db2, name);
+    if (nameConflict) {
+      const parts = this.repoPath.split("/");
+      const parent = parts.length >= 2 ? parts[parts.length - 2] : "repo";
+      name = `${parent}-${name}`;
+    }
+    const repo = insertRepo(db2, name, this.repoPath);
+    this.repoId = repo.id;
+    return { id: toEntryId(repo.id), name: repo.name, path: repo.path };
+  }
+  getWorkspace() {
+    if (!this.repoPath) {
+      this.repoPath = detectRepoPath();
+    }
+    return detectWorkspaceFromPath(this.repoPath);
+  }
+  // ── Notes ──
+  insertNote(content, topic) {
+    const db2 = getDb();
+    this.ensureRepo();
+    const topicId = topic ? resolveTopicId(db2, topic) : null;
+    const note = insertNote(db2, this.repoId, topicId, content);
+    const ws = this.getWorkspace();
+    return {
+      id: toEntryId(note.id),
+      type: "note",
+      date: note.created_at,
+      project: ws.project,
+      workspace: ws.workspace,
+      topic: note.topic_name,
+      tags: note.topic_name ? [note.topic_name] : [],
+      content: note.content
+    };
+  }
+  getNotes(filters) {
+    const db2 = getDb();
+    const ws = this.getWorkspace();
+    const notes = getNotes(db2, {
+      repoId: filters.repoId ? toNumericId(filters.repoId) : this.repoId ?? void 0,
+      topicId: filters.topicId ? toNumericId(filters.topicId) : void 0,
+      from: filters.from,
+      to: filters.to,
+      limit: filters.limit
+    });
+    return notes.map((n) => ({
+      id: toEntryId(n.id),
+      type: "note",
+      date: n.created_at,
+      project: ws.project,
+      workspace: ws.workspace,
+      topic: n.topic_name,
+      tags: n.topic_name ? [n.topic_name] : [],
+      content: n.content
+    }));
+  }
+  // ── TODOs ──
+  insertTodo(content, opts) {
+    const db2 = getDb();
+    this.ensureRepo();
+    const topicId = opts?.topic ? resolveTopicId(db2, opts.topic) : null;
+    const todo = insertTodo(
+      db2,
+      this.repoId,
+      topicId,
+      content,
+      opts?.priority || "normal",
+      opts?.remind_at,
+      opts?.remind_pattern
+    );
+    const ws = this.getWorkspace();
+    return this.todoToEntry(todo, ws);
+  }
+  getTodos(filters) {
+    const db2 = getDb();
+    const ws = this.getWorkspace();
+    const todos = getTodos(db2, {
+      status: filters.status === "all" ? void 0 : filters.status || "pending",
+      repoId: filters.repoId ? toNumericId(filters.repoId) : filters.status !== "all" ? this.repoId ?? void 0 : void 0,
+      topicId: filters.topicId ? toNumericId(filters.topicId) : void 0,
+      priority: filters.priority,
+      from: filters.from,
+      to: filters.to,
+      limit: filters.limit
+    });
+    return todos.map((t) => this.todoToEntry(t, ws));
+  }
+  updateTodoStatus(ids, status) {
+    const db2 = getDb();
+    const ws = this.getWorkspace();
+    const numericIds = ids.map(toNumericId);
+    const todos = updateTodoStatus(db2, numericIds, status);
+    return todos.map((t) => this.todoToEntry(t, ws));
+  }
+  updateTodo(id, fields) {
+    const db2 = getDb();
+    const ws = this.getWorkspace();
+    const updateFields = {};
+    if (fields.content !== void 0) updateFields.content = fields.content;
+    if (fields.topic !== void 0) updateFields.topicId = resolveTopicId(db2, fields.topic);
+    if (fields.priority !== void 0) updateFields.priority = fields.priority;
+    const todo = updateTodo(db2, toNumericId(id), updateFields);
+    if (!todo) return null;
+    return this.todoToEntry(todo, ws);
+  }
+  deleteTodos(ids) {
+    const db2 = getDb();
+    const numericIds = ids.map(toNumericId);
+    const deleted = deleteTodos(db2, numericIds);
+    return deleted.map(toEntryId);
+  }
+  ackRecurringReminder(id) {
+    const db2 = getDb();
+    ackRecurringReminder(db2, toNumericId(id));
+  }
+  // ── Specialized entries (stored as notes with topic in SQLite) ──
+  insertStandup(yesterday, today, blockers, topic) {
+    const content = `## Yesterday
+${yesterday}
+
+## Today
+${today}
+
+## Blockers
+${blockers || "Ninguno"}`;
+    const note = this.insertNote(content, topic || "chore");
+    return {
+      ...note,
+      type: "standup",
+      yesterday,
+      today,
+      blockers: blockers || "Ninguno"
+    };
+  }
+  insertDecision(title, context, options, decision, consequences, topic) {
+    const optionsList = options.map((o, i) => `${i + 1}. ${o}`).join("\n");
+    const content = `# ${title}
+
+## Contexto
+${context}
+
+## Opciones
+${optionsList}
+
+## Decision
+${decision}
+
+## Consecuencias
+${consequences}`;
+    const note = this.insertNote(content, topic || "decision");
+    return {
+      ...note,
+      type: "decision",
+      title,
+      context,
+      options,
+      decision,
+      consequences
+    };
+  }
+  insertDebug(title, error, cause, fix, file, topic) {
+    const fileLine = file ? `
+
+## Archivo
+${file}` : "";
+    const content = `# ${title}
+
+## Error
+${error}
+
+## Causa
+${cause}
+
+## Fix
+${fix}${fileLine}`;
+    const note = this.insertNote(content, topic || "fix");
+    return {
+      ...note,
+      type: "debug",
+      title,
+      error,
+      cause,
+      fix,
+      attachment: file || null
+    };
+  }
+  // ── Search & queries ──
+  search(query, filters) {
+    const db2 = getDb();
+    const ws = this.getWorkspace();
+    const results = [];
+    const topicId = filters.topic ? this.resolveTopicSafe(db2, filters.topic) : void 0;
+    const repoId = filters.scope === "global" ? void 0 : this.repoId ?? void 0;
+    if (!filters.type || filters.type === "all" || filters.type === "notes") {
+      const notes = searchNotes(db2, query, { repoId, topicId, limit: filters.limit });
+      for (const n of notes) {
+        results.push({
+          type: "note",
+          data: {
+            id: toEntryId(n.id),
+            type: "note",
+            date: n.created_at,
+            project: ws.project,
+            workspace: ws.workspace,
+            topic: n.topic_name,
+            tags: n.topic_name ? [n.topic_name] : [],
+            content: n.content
+          },
+          rank: n.rank || 0
+        });
+      }
+    }
+    if (!filters.type || filters.type === "all" || filters.type === "todos") {
+      const todos = searchTodos(db2, query, { repoId, topicId, limit: filters.limit });
+      for (const t of todos) {
+        results.push({
+          type: "todo",
+          data: {
+            id: toEntryId(t.id),
+            type: "todo",
+            date: t.created_at,
+            project: ws.project,
+            workspace: ws.workspace,
+            topic: t.topic_name,
+            tags: t.topic_name ? [t.topic_name] : [],
+            content: t.content
+          },
+          rank: t.rank || 0
+        });
+      }
+    }
+    return results.sort((a, b) => a.rank - b.rank);
+  }
+  getLog(filters) {
+    const db2 = getDb();
+    const ws = this.getWorkspace();
+    const { from, to } = this.resolveDates(filters);
+    const topicId = filters.topic ? this.resolveTopicSafe(db2, filters.topic) : void 0;
+    const repoId = filters.scope === "global" ? void 0 : this.repoId ?? void 0;
+    const entries = [];
+    if (!filters.type || filters.type === "all" || filters.type === "notes") {
+      const notes = getNotes(db2, { repoId, topicId, from, to });
+      for (const n of notes) {
+        entries.push({
+          type: "note",
+          data: {
+            id: toEntryId(n.id),
+            type: "note",
+            date: n.created_at,
+            project: ws.project,
+            workspace: ws.workspace,
+            topic: n.topic_name,
+            tags: n.topic_name ? [n.topic_name] : [],
+            content: n.content
+          },
+          timestamp: n.created_at
+        });
+      }
+    }
+    if (!filters.type || filters.type === "all" || filters.type === "todos") {
+      const todos = getCompletedTodos(db2, { repoId, topicId, from, to });
+      for (const t of todos) {
+        entries.push({
+          type: "todo",
+          data: {
+            id: toEntryId(t.id),
+            type: "todo",
+            date: t.created_at,
+            project: ws.project,
+            workspace: ws.workspace,
+            topic: t.topic_name,
+            tags: t.topic_name ? [t.topic_name] : [],
+            content: t.content
+          },
+          timestamp: t.completed_at || t.created_at
+        });
+      }
+      if (repoId) {
+        const resolved = getResolvedCodeTodos(db2, repoId, from, to);
+        for (const r of resolved) {
+          entries.push({
+            type: "code_todo_resolved",
+            data: {
+              id: toEntryId(r.id),
+              type: "todo",
+              date: r.first_seen_at,
+              project: ws.project,
+              workspace: ws.workspace,
+              topic: r.topic_name,
+              tags: [r.topic_name],
+              file: r.file,
+              line: r.line,
+              tag: r.tag,
+              content: r.content
+            },
+            timestamp: r.resolved_at || r.first_seen_at
+          });
+        }
+      }
+    }
+    return entries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  }
+  getDueReminders() {
+    const db2 = getDb();
+    const result = getDueReminders(db2);
+    if (!result) return null;
+    const ws = this.getWorkspace();
+    return {
+      today: result.today.map((g) => ({
+        repo_name: g.repo_name,
+        reminders: g.reminders.map((r) => this.todoToEntry(r, ws))
+      })),
+      overdue: result.overdue.map((g) => ({
+        repo_name: g.repo_name,
+        reminders: g.reminders.map((r) => this.todoToEntry(r, ws))
+      })),
+      recurring: result.recurring.map((g) => ({
+        repo_name: g.repo_name,
+        reminders: g.reminders.map((r) => this.todoToEntry(r, ws))
+      }))
+    };
+  }
+  getTags(filter) {
+    const db2 = getDb();
+    const topics = getAllTopics(db2);
+    const results = topics.map((t) => ({
+      tag: t.name,
+      count: 0
+      // SQLite mode: count not tracked per-tag
+    }));
+    if (filter) {
+      return results.filter((r) => r.tag === filter);
+    }
+    return results;
+  }
+  getTimeline(filters) {
+    const logEntries = this.getLog({
+      period: filters.period,
+      from: filters.from,
+      to: filters.to,
+      scope: "global"
+    });
+    return logEntries.map((e) => ({
+      type: e.data.type,
+      date: e.timestamp,
+      workspace: e.data.workspace,
+      project: e.data.project,
+      summary: (e.data.content || "").slice(0, 100)
+    }));
+  }
+  // ── Topics ──
+  getTopics() {
+    const db2 = getDb();
+    const topics = getAllTopics(db2);
+    return topics.map((t) => ({
+      id: toEntryId(t.id),
+      name: t.name,
+      description: t.description,
+      is_custom: t.is_custom === 1
+    }));
+  }
+  insertTopic(name, description) {
+    const db2 = getDb();
+    const topic = insertTopic(db2, name, description);
+    return {
+      id: toEntryId(topic.id),
+      name: topic.name,
+      description: topic.description,
+      is_custom: topic.is_custom === 1
+    };
+  }
+  // ── Code TODOs ──
+  getCodeTodos(repoPath) {
+    return scanCodeTodos(repoPath);
+  }
+  syncCodeTodos(_repoPath, todos) {
+    const db2 = getDb();
+    this.ensureRepo();
+    if (!this.repoId) return { added: 0, resolved: 0 };
+    return syncCodeTodos(db2, this.repoId, todos);
+  }
+  // ── Private helpers ──
+  ensureRepo() {
+    if (this.repoId === null) {
+      this.autoRegisterRepo();
+    }
+  }
+  todoToEntry(todo, ws) {
+    return {
+      id: toEntryId(todo.id),
+      type: "todo",
+      date: todo.created_at,
+      project: ws.project,
+      workspace: ws.workspace,
+      topic: todo.topic_name,
+      tags: todo.topic_name ? [todo.topic_name] : [],
+      content: todo.content,
+      status: todo.status,
+      priority: todo.priority,
+      due: todo.remind_at,
+      remind_pattern: todo.remind_pattern,
+      remind_last_done: todo.remind_last_done,
+      completed_at: todo.completed_at
+    };
+  }
+  resolveTopicSafe(db2, name) {
+    const topic = getTopicByName(db2, name);
+    return topic?.id;
+  }
+  resolveDates(filters) {
+    if (filters.from || filters.to) {
+      return { from: filters.from, to: filters.to };
+    }
+    const now = /* @__PURE__ */ new Date();
+    const today = todayDate();
+    switch (filters.period) {
+      case "today":
+        return { from: `${today}T00:00:00`, to: `${today}T23:59:59` };
+      case "yesterday": {
+        const yesterday = new Date(now.getTime() - 864e5).toISOString().split("T")[0];
+        return { from: `${yesterday}T00:00:00`, to: `${yesterday}T23:59:59` };
+      }
+      case "week": {
+        const weekAgo = new Date(now.getTime() - 7 * 864e5).toISOString().split("T")[0];
+        return { from: `${weekAgo}T00:00:00`, to: `${today}T23:59:59` };
+      }
+      case "month": {
+        const monthAgo = new Date(now.getTime() - 30 * 864e5).toISOString().split("T")[0];
+        return { from: `${monthAgo}T00:00:00`, to: `${today}T23:59:59` };
+      }
+      default:
+        return { from: `${today}T00:00:00`, to: `${today}T23:59:59` };
+    }
+  }
+};
+
+// src/storage/obsidian/index.ts
+import { existsSync as existsSync4, unlinkSync } from "fs";
+import { basename as basename5, join as join5 } from "path";
+
+// src/storage/obsidian/slug.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var ACCENT_MAP = {
+  "\xE1": "a",
+  "\xE0": "a",
+  "\xE4": "a",
+  "\xE2": "a",
+  "\xE3": "a",
+  "\xE9": "e",
+  "\xE8": "e",
+  "\xEB": "e",
+  "\xEA": "e",
+  "\xED": "i",
+  "\xEC": "i",
+  "\xEF": "i",
+  "\xEE": "i",
+  "\xF3": "o",
+  "\xF2": "o",
+  "\xF6": "o",
+  "\xF4": "o",
+  "\xF5": "o",
+  "\xFA": "u",
+  "\xF9": "u",
+  "\xFC": "u",
+  "\xFB": "u",
+  "\xF1": "n",
+  "\xE7": "c"
+};
+function generateSlug(text, maxLen = 50) {
+  let slug = text.toLowerCase();
+  slug = slug.replace(/[áàäâãéèëêíìïîóòöôõúùüûñç]/g, (ch) => ACCENT_MAP[ch] || ch);
+  slug = slug.replace(/[^a-z0-9]+/g, "-");
+  slug = slug.replace(/-{2,}/g, "-");
+  slug = slug.replace(/^-|-$/g, "");
+  if (slug.length > maxLen) {
+    slug = slug.slice(0, maxLen).replace(/-$/, "");
+  }
+  return slug || "entry";
+}
+function resolveFilename(dir, date, slug) {
+  const base = `${date}-${slug}.md`;
+  const fullPath = join2(dir, base);
+  if (!existsSync2(fullPath)) return base;
+  let counter = 2;
+  while (true) {
+    const candidate = `${date}-${slug}-${counter}.md`;
+    if (!existsSync2(join2(dir, candidate))) return candidate;
+    counter++;
+  }
+}
+
+// src/storage/obsidian/workspace.ts
+import { basename as basename3 } from "path";
+function detectWorkspace(repoPath) {
+  if (!repoPath) {
+    return {
+      workspace: process.env.LOGBOOK_WORKSPACE || "default",
+      project: "global"
+    };
+  }
+  const normalized = repoPath.replace(/\\/g, "/");
+  const project = basename3(normalized);
+  const lowerPath = normalized.toLowerCase();
+  const projectsIdx = lowerPath.indexOf("/projects/");
+  if (projectsIdx !== -1) {
+    const before = normalized.slice(0, projectsIdx);
+    const workspace = basename3(before);
+    if (workspace) {
+      return { workspace, project };
+    }
+  }
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length >= 2) {
+    return { workspace: parts[parts.length - 2], project };
+  }
+  return {
+    workspace: process.env.LOGBOOK_WORKSPACE || "default",
+    project
+  };
+}
+
+// src/storage/obsidian/wikilinks.ts
+import { readdirSync } from "fs";
+import { join as join3 } from "path";
+function getKnownProjects(baseDir) {
+  const projects = [];
+  try {
+    const workspaces = readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const ws of workspaces) {
+      try {
+        const projectDirs = readdirSync(join3(baseDir, ws.name), { withFileTypes: true }).filter((d) => d.isDirectory());
+        for (const proj of projectDirs) {
+          projects.push(proj.name);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return [...new Set(projects)];
+}
+function applyWikilinks(content, knownProjects) {
+  if (knownProjects.length === 0) return content;
+  let result = content;
+  for (const project of knownProjects) {
+    if (project.length < 3) continue;
+    const escaped = project.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`(?<!\\[\\[)\\b(${escaped})\\b(?!\\]\\])`, "g");
+    result = result.replace(regex, "[[$1]]");
+  }
+  return result;
+}
+
+// src/storage/obsidian/files.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync, writeFileSync, copyFileSync, readdirSync as readdirSync2 } from "fs";
+import { join as join4, basename as basename4 } from "path";
+
+// src/storage/obsidian/frontmatter.ts
+function parseFrontmatter(raw) {
+  const lines = raw.split("\n");
+  const firstIdx = lines.findIndex((l) => l.trim() === "---");
+  if (firstIdx === -1) {
+    return { frontmatter: {}, body: raw };
+  }
+  const secondIdx = lines.findIndex((l, i) => i > firstIdx && l.trim() === "---");
+  if (secondIdx === -1) {
+    return { frontmatter: {}, body: raw };
+  }
+  const fmLines = lines.slice(firstIdx + 1, secondIdx);
+  const frontmatter = {};
+  for (const line of fmLines) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const rawValue = line.slice(colonIdx + 1).trim();
+    if (!key) continue;
+    frontmatter[key] = parseValue(rawValue);
+  }
+  const body = lines.slice(secondIdx + 1).join("\n").replace(/^\n/, "");
+  return { frontmatter, body };
+}
+function serializeFrontmatter(data) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(data)) {
+    if (value === null || value === void 0) continue;
+    lines.push(`${key}: ${serializeValue(value)}`);
+  }
+  lines.push("---");
+  return lines.join("\n") + "\n";
+}
+function parseValue(raw) {
+  if (raw === "" || raw === "null" || raw === "~") return null;
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw.startsWith("[") && raw.endsWith("]")) {
+    const inner = raw.slice(1, -1).trim();
+    if (inner === "") return [];
+    return inner.split(",").map((item) => item.trim().replace(/^["']|["']$/g, ""));
+  }
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  if (/^\d+(\.\d+)?$/.test(raw)) {
+    return Number(raw);
+  }
+  return raw;
+}
+function serializeValue(value) {
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "number") return String(value);
+  if (Array.isArray(value)) {
+    return `[${value.join(", ")}]`;
+  }
+  if (typeof value === "string" && /[:#\[\]{},>|&*!%@`]/.test(value)) {
+    return `"${value.replace(/"/g, '\\"')}"`;
+  }
+  return String(value);
+}
+
+// src/storage/obsidian/files.ts
+function ensureDir(dir) {
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
+function globMarkdown(dir) {
+  const results = [];
+  if (!existsSync3(dir)) return results;
+  function walk(currentDir) {
+    const entries = readdirSync2(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join4(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+function readEntry(path) {
+  const raw = readFileSync(path, "utf-8");
+  return parseFrontmatter(raw);
+}
+function writeEntry(path, frontmatter, body) {
+  const dir = join4(path, "..");
+  ensureDir(dir);
+  const content = serializeFrontmatter(frontmatter) + "\n" + body;
+  writeFileSync(path, content, "utf-8");
+}
+function copyAttachment(src, destDir) {
+  ensureDir(destDir);
+  const filename = basename4(src);
+  let destPath = join4(destDir, filename);
+  if (existsSync3(destPath)) {
+    const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")) : "";
+    const name = filename.includes(".") ? filename.slice(0, filename.lastIndexOf(".")) : filename;
+    let counter = 2;
+    while (existsSync3(destPath)) {
+      destPath = join4(destDir, `${name}-${counter}${ext}`);
+      counter++;
+    }
+  }
+  copyFileSync(src, destPath);
+  return basename4(destPath);
+}
+function extractIdFromFilename(filename) {
+  return filename.replace(/\.md$/, "");
+}
+
+// src/storage/obsidian/formatting.ts
+var PRIORITY_EMOJI = {
+  urgent: "\u23EB",
+  // ⏫
+  high: "\u{1F53C}",
+  // 🔼
+  normal: "",
+  low: "\u{1F53D}"
+  // 🔽
+};
+function formatTodoCheckbox(content, priority, due, done, completedAt) {
+  const checkbox = done ? "- [x]" : "- [ ]";
+  const parts = [checkbox, content];
+  const emoji = PRIORITY_EMOJI[priority];
+  if (emoji) parts.push(emoji);
+  if (due && !done) {
+    parts.push(`\u{1F4C5} ${due}`);
+  }
+  if (done && completedAt) {
+    parts.push(`\u2705 ${completedAt.split("T")[0]}`);
+  }
+  return parts.join(" ");
+}
+function formatStandup(yesterday, today, blockers) {
+  return [
+    "## Yesterday",
+    yesterday,
+    "",
+    "## Today",
+    today,
+    "",
+    "## Blockers",
+    blockers || "Ninguno"
+  ].join("\n");
+}
+function formatDecision(title, context, options, decision, consequences) {
+  const optionsList = options.map((o, i) => `${i + 1}. ${o}`).join("\n");
+  return [
+    `# ${title}`,
+    "",
+    "## Contexto",
+    context,
+    "",
+    "## Opciones",
+    optionsList,
+    "",
+    "## Decision",
+    decision,
+    "",
+    "## Consecuencias",
+    consequences
+  ].join("\n");
+}
+function formatDebug(title, error, cause, fix, attachment) {
+  const parts = [
+    `> [!bug] ${title}`,
+    ">",
+    "> **Error**",
+    `> ${error}`,
+    ">",
+    "> **Causa**",
+    `> ${cause}`,
+    ">",
+    "> **Fix**",
+    `> ${fix}`
+  ];
+  if (attachment) {
+    parts.push(">", `> ![[${attachment}]]`);
+  }
+  return parts.join("\n");
+}
+
+// src/storage/obsidian/index.ts
+var TYPE_FOLDERS = {
+  note: "notes",
+  todo: "todos",
+  decision: "decisions",
+  debug: "debug",
+  standup: "standups"
+};
+function todayDate2() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function matchesPattern2(pattern, date) {
+  const dayOfWeek = date.getDay();
+  const dayOfMonth = date.getDate();
+  if (pattern === "daily") return true;
+  if (pattern === "weekdays") return dayOfWeek >= 1 && dayOfWeek <= 5;
+  if (pattern.startsWith("weekly:")) {
+    const days = pattern.slice(7).split(",").map(Number);
+    return days.some((d) => d % 7 === dayOfWeek);
+  }
+  if (pattern.startsWith("monthly:")) {
+    const days = pattern.slice(8).split(",").map(Number);
+    return days.includes(dayOfMonth);
+  }
+  return false;
+}
+var ObsidianStorage = class {
+  baseDir;
+  repoPath = null;
+  wsInfo = null;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+    ensureDir(baseDir);
+  }
+  // ── Repos ──
+  autoRegisterRepo() {
+    this.repoPath = detectRepoPath();
+    if (!this.repoPath) return null;
+    this.wsInfo = detectWorkspace(this.repoPath);
+    const name = basename5(this.repoPath);
+    return {
+      id: name,
+      name,
+      path: this.repoPath
+    };
+  }
+  getWorkspace() {
+    if (!this.wsInfo) {
+      if (!this.repoPath) this.repoPath = detectRepoPath();
+      this.wsInfo = detectWorkspace(this.repoPath);
+    }
+    return this.wsInfo;
+  }
+  // ── Notes ──
+  insertNote(content, topic) {
+    const ws = this.getWorkspace();
+    const date = todayDate2();
+    const slug = generateSlug(content.slice(0, 80));
+    const dir = this.typeDir(ws, "note");
+    const filename = resolveFilename(dir, date, slug);
+    const id = extractIdFromFilename(filename);
+    const knownProjects = getKnownProjects(this.baseDir);
+    const body = applyWikilinks(content, knownProjects);
+    const fm = {
+      type: "note",
+      date,
+      project: ws.project,
+      workspace: ws.workspace
+    };
+    if (topic) fm.topic = topic;
+    if (topic) fm.tags = [topic];
+    writeEntry(join5(dir, filename), fm, body);
+    return {
+      id,
+      type: "note",
+      date,
+      project: ws.project,
+      workspace: ws.workspace,
+      topic: topic || null,
+      tags: topic ? [topic] : [],
+      content: body
+    };
+  }
+  getNotes(filters) {
+    const ws = this.getWorkspace();
+    const dir = this.typeDir(ws, "note");
+    const files = globMarkdown(dir);
+    return this.filterAndMap(files, filters, (fm, body, id) => ({
+      id,
+      type: "note",
+      date: String(fm.date || ""),
+      project: String(fm.project || ws.project),
+      workspace: String(fm.workspace || ws.workspace),
+      topic: fm.topic,
+      tags: fm.tags || [],
+      content: body
+    }));
+  }
+  // ── TODOs ──
+  insertTodo(content, opts) {
+    const ws = this.getWorkspace();
+    const date = todayDate2();
+    const priority = opts?.priority || "normal";
+    const slug = generateSlug(content.slice(0, 80));
+    const dir = this.typeDir(ws, "todo");
+    const filename = resolveFilename(dir, date, slug);
+    const id = extractIdFromFilename(filename);
+    const fm = {
+      type: "todo",
+      date,
+      project: ws.project,
+      workspace: ws.workspace,
+      status: "pending",
+      priority
+    };
+    if (opts?.topic) {
+      fm.topic = opts.topic;
+      fm.tags = [opts.topic];
+    }
+    if (opts?.remind_at) fm.due = opts.remind_at;
+    if (opts?.remind_pattern) fm.remind_pattern = opts.remind_pattern;
+    const body = formatTodoCheckbox(content, priority, opts?.remind_at);
+    writeEntry(join5(dir, filename), fm, body);
+    return {
+      id,
+      type: "todo",
+      date,
+      project: ws.project,
+      workspace: ws.workspace,
+      topic: opts?.topic || null,
+      tags: opts?.topic ? [opts.topic] : [],
+      content,
+      status: "pending",
+      priority,
+      due: opts?.remind_at || null,
+      remind_pattern: opts?.remind_pattern || null,
+      remind_last_done: null,
+      completed_at: null
+    };
+  }
+  getTodos(filters) {
+    const ws = this.getWorkspace();
+    const dir = this.typeDir(ws, "todo");
+    const files = globMarkdown(dir);
+    return this.filterAndMap(files, filters, (fm, body, id) => ({
+      id,
+      type: "todo",
+      date: String(fm.date || ""),
+      project: String(fm.project || ws.project),
+      workspace: String(fm.workspace || ws.workspace),
+      topic: fm.topic || null,
+      tags: fm.tags || [],
+      content: this.extractTodoContent(body),
+      status: fm.status || "pending",
+      priority: fm.priority || "normal",
+      due: fm.due || null,
+      remind_pattern: fm.remind_pattern || null,
+      remind_last_done: fm.remind_last_done || null,
+      completed_at: fm.completed_at || null
+    })).filter((t) => {
+      if (filters.status && filters.status !== "all" && t.status !== filters.status) return false;
+      if (filters.priority && t.priority !== filters.priority) return false;
+      return true;
+    });
+  }
+  updateTodoStatus(ids, status) {
+    const ws = this.getWorkspace();
+    const dir = this.typeDir(ws, "todo");
+    const results = [];
+    for (const id of ids) {
+      const path = this.findFileById(dir, id);
+      if (!path) continue;
+      const { frontmatter: fm, body } = readEntry(path);
+      fm.status = status;
+      if (status === "done") {
+        fm.completed_at = nowISO();
+      } else {
+        fm.completed_at = null;
+      }
+      const content = this.extractTodoContent(body);
+      const newBody = formatTodoCheckbox(
+        content,
+        fm.priority || "normal",
+        fm.due,
+        status === "done",
+        fm.completed_at
+      );
+      writeEntry(path, fm, newBody);
+      results.push({
+        id,
+        type: "todo",
+        date: String(fm.date || ""),
+        project: String(fm.project || ws.project),
+        workspace: String(fm.workspace || ws.workspace),
+        topic: fm.topic || null,
+        tags: fm.tags || [],
+        content,
+        status,
+        priority: fm.priority || "normal",
+        due: fm.due || null,
+        remind_pattern: fm.remind_pattern || null,
+        remind_last_done: fm.remind_last_done || null,
+        completed_at: fm.completed_at || null
+      });
+    }
+    return results;
+  }
+  updateTodo(id, fields) {
+    const ws = this.getWorkspace();
+    const dir = this.typeDir(ws, "todo");
+    const path = this.findFileById(dir, id);
+    if (!path) return null;
+    const { frontmatter: fm } = readEntry(path);
+    if (fields.content !== void 0) {
+    }
+    if (fields.topic !== void 0) {
+      fm.topic = fields.topic;
+      fm.tags = [fields.topic];
+    }
+    if (fields.priority !== void 0) fm.priority = fields.priority;
+    const content = fields.content ?? this.extractTodoContent(readEntry(path).body);
+    const newBody = formatTodoCheckbox(
+      content,
+      fm.priority || "normal",
+      fm.due,
+      fm.status === "done",
+      fm.completed_at
+    );
+    writeEntry(path, fm, newBody);
+    return {
+      id,
+      type: "todo",
+      date: String(fm.date || ""),
+      project: String(fm.project || ws.project),
+      workspace: String(fm.workspace || ws.workspace),
+      topic: fm.topic || null,
+      tags: fm.tags || [],
+      content,
+      status: fm.status || "pending",
+      priority: fm.priority || "normal",
+      due: fm.due || null,
+      remind_pattern: fm.remind_pattern || null,
+      remind_last_done: fm.remind_last_done || null,
+      completed_at: fm.completed_at || null
+    };
+  }
+  deleteTodos(ids) {
+    const ws = this.getWorkspace();
+    const dir = this.typeDir(ws, "todo");
+    const deleted = [];
+    for (const id of ids) {
+      const path = this.findFileById(dir, id);
+      if (path && existsSync4(path)) {
+        unlinkSync(path);
+        deleted.push(id);
+      }
+    }
+    return deleted;
+  }
+  ackRecurringReminder(id) {
+    const ws = this.getWorkspace();
+    const dir = this.typeDir(ws, "todo");
+    const path = this.findFileById(dir, id);
+    if (!path) return;
+    const { frontmatter: fm, body } = readEntry(path);
+    fm.remind_last_done = todayDate2();
+    writeEntry(path, fm, body);
+  }
+  // ── Specialized entries ──
+  insertStandup(yesterday, today, blockers, topic) {
+    const ws = this.getWorkspace();
+    const date = todayDate2();
+    const slug = `standup-${date}`;
+    const dir = this.typeDir(ws, "standup");
+    const filename = resolveFilename(dir, date, slug);
+    const id = extractIdFromFilename(filename);
+    const fm = {
+      type: "standup",
+      date,
+      project: ws.project,
+      workspace: ws.workspace
+    };
+    if (topic) {
+      fm.topic = topic;
+      fm.tags = [topic];
+    }
+    const knownProjects = getKnownProjects(this.baseDir);
+    const body = applyWikilinks(formatStandup(yesterday, today, blockers), knownProjects);
+    writeEntry(join5(dir, filename), fm, body);
+    return {
+      id,
+      type: "standup",
+      date,
+      project: ws.project,
+      workspace: ws.workspace,
+      topic: topic || null,
+      tags: topic ? [topic] : [],
+      yesterday,
+      today,
+      blockers: blockers || "Ninguno"
+    };
+  }
+  insertDecision(title, context, options, decision, consequences, topic) {
+    const ws = this.getWorkspace();
+    const date = todayDate2();
+    const slug = generateSlug(title);
+    const dir = this.typeDir(ws, "decision");
+    const filename = resolveFilename(dir, date, slug);
+    const id = extractIdFromFilename(filename);
+    const fm = {
+      type: "decision",
+      date,
+      project: ws.project,
+      workspace: ws.workspace
+    };
+    if (topic) {
+      fm.topic = topic || "decision";
+      fm.tags = [topic || "decision"];
+    }
+    const knownProjects = getKnownProjects(this.baseDir);
+    const body = applyWikilinks(formatDecision(title, context, options, decision, consequences), knownProjects);
+    writeEntry(join5(dir, filename), fm, body);
+    return {
+      id,
+      type: "decision",
+      date,
+      project: ws.project,
+      workspace: ws.workspace,
+      topic: topic || "decision",
+      tags: [topic || "decision"],
+      title,
+      context,
+      options,
+      decision,
+      consequences
+    };
+  }
+  insertDebug(title, error, cause, fix, file, topic) {
+    const ws = this.getWorkspace();
+    const date = todayDate2();
+    const slug = generateSlug(title);
+    const dir = this.typeDir(ws, "debug");
+    const filename = resolveFilename(dir, date, slug);
+    const id = extractIdFromFilename(filename);
+    let attachmentName = null;
+    if (file) {
+      if (!existsSync4(file)) {
+        throw new Error(`Archivo no encontrado: ${file}`);
+      }
+      const attachDir = join5(this.projectDir(ws), "attachments");
+      attachmentName = copyAttachment(file, attachDir);
+    }
+    const fm = {
+      type: "debug",
+      date,
+      project: ws.project,
+      workspace: ws.workspace
+    };
+    if (topic) {
+      fm.topic = topic || "fix";
+      fm.tags = [topic || "fix"];
+    }
+    const knownProjects = getKnownProjects(this.baseDir);
+    const body = applyWikilinks(formatDebug(title, error, cause, fix, attachmentName), knownProjects);
+    writeEntry(join5(dir, filename), fm, body);
+    return {
+      id,
+      type: "debug",
+      date,
+      project: ws.project,
+      workspace: ws.workspace,
+      topic: topic || "fix",
+      tags: [topic || "fix"],
+      title,
+      error,
+      cause,
+      fix,
+      attachment: attachmentName
+    };
+  }
+  // ── Search & queries ──
+  search(query, filters) {
+    const ws = this.getWorkspace();
+    const searchDir = filters.scope === "global" ? this.baseDir : this.projectDir(ws);
+    const files = globMarkdown(searchDir);
+    const queryLower = query.toLowerCase();
+    const results = [];
+    for (const file of files) {
+      const { frontmatter: fm, body } = readEntry(file);
+      if (filters.type && filters.type !== "all") {
+        const fmType = fm.type;
+        if (filters.type === "notes" && fmType !== "note") continue;
+        if (filters.type === "todos" && fmType !== "todo") continue;
+      }
+      if (filters.topic && fm.topic !== filters.topic) continue;
+      const searchable = `${body} ${Object.values(fm).join(" ")}`.toLowerCase();
+      if (!searchable.includes(queryLower)) continue;
+      results.push({
+        type: fm.type || "note",
+        data: {
+          id: extractIdFromFilename(basename5(file)),
+          type: fm.type || "note",
+          date: String(fm.date || ""),
+          project: String(fm.project || ws.project),
+          workspace: String(fm.workspace || ws.workspace),
+          topic: fm.topic || null,
+          tags: fm.tags || [],
+          content: body
+        },
+        rank: 0
+      });
+    }
+    return results.slice(0, filters.limit || 20);
+  }
+  getLog(filters) {
+    const ws = this.getWorkspace();
+    const { from, to } = this.resolveDates(filters);
+    const searchDir = filters.scope === "global" ? this.baseDir : this.projectDir(ws);
+    const files = globMarkdown(searchDir);
+    const entries = [];
+    for (const file of files) {
+      const { frontmatter: fm, body } = readEntry(file);
+      const date = String(fm.date || "");
+      if (!date) continue;
+      if (from && date < from.split("T")[0]) continue;
+      if (to && date > to.split("T")[0]) continue;
+      const fmType = fm.type || "note";
+      if (filters.type && filters.type !== "all") {
+        if (filters.type === "notes" && fmType !== "note" && fmType !== "decision" && fmType !== "debug" && fmType !== "standup") continue;
+        if (filters.type === "todos" && fmType !== "todo") continue;
+      }
+      if (filters.topic && fm.topic !== filters.topic) continue;
+      entries.push({
+        type: fmType,
+        data: {
+          id: extractIdFromFilename(basename5(file)),
+          type: fmType,
+          date,
+          project: String(fm.project || ws.project),
+          workspace: String(fm.workspace || ws.workspace),
+          topic: fm.topic || null,
+          tags: fm.tags || [],
+          content: body
+        },
+        timestamp: String(fm.completed_at || fm.date || "")
+      });
+    }
+    return entries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  }
+  getDueReminders() {
+    const ws = this.getWorkspace();
+    const dir = this.typeDir(ws, "todo");
+    const files = globMarkdown(dir);
+    const today = todayDate2();
+    const now = /* @__PURE__ */ new Date();
+    const todayItems = [];
+    const overdueItems = [];
+    const recurringItems = [];
+    for (const file of files) {
+      const { frontmatter: fm, body } = readEntry(file);
+      if (fm.status !== "pending") continue;
+      const id = extractIdFromFilename(basename5(file));
+      const entry = {
+        id,
+        type: "todo",
+        date: String(fm.date || ""),
+        project: String(fm.project || ws.project),
+        workspace: String(fm.workspace || ws.workspace),
+        topic: fm.topic || null,
+        tags: fm.tags || [],
+        content: this.extractTodoContent(body),
+        status: "pending",
+        priority: fm.priority || "normal",
+        due: fm.due || null,
+        remind_pattern: fm.remind_pattern || null,
+        remind_last_done: fm.remind_last_done || null,
+        completed_at: null
+      };
+      if (fm.due) {
+        const due = String(fm.due);
+        if (due === today) {
+          todayItems.push(entry);
+        } else if (due < today && !fm.remind_pattern) {
+          overdueItems.push(entry);
+        }
+      }
+      if (fm.remind_pattern) {
+        const lastDone = fm.remind_last_done;
+        if (!lastDone || lastDone < today) {
+          if (matchesPattern2(String(fm.remind_pattern), now)) {
+            recurringItems.push(entry);
+          }
+        }
+      }
+    }
+    if (todayItems.length === 0 && overdueItems.length === 0 && recurringItems.length === 0) {
+      return null;
+    }
+    return {
+      today: this.groupByProject(todayItems),
+      overdue: this.groupByProject(overdueItems),
+      recurring: this.groupByProject(recurringItems)
+    };
+  }
+  getTags(filter) {
+    const files = globMarkdown(this.baseDir);
+    const tagCounts = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const { frontmatter: fm } = readEntry(file);
+      const tags = fm.tags;
+      if (!tags || !Array.isArray(tags)) continue;
+      for (const tag of tags) {
+        tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+      }
+    }
+    const results = Array.from(tagCounts.entries()).map(([tag, count]) => ({ tag, count })).sort((a, b) => b.count - a.count);
+    if (filter) {
+      return results.filter((r) => r.tag === filter);
+    }
+    return results;
+  }
+  getTimeline(filters) {
+    const { from, to } = this.resolveDates({
+      period: filters.period,
+      from: filters.from,
+      to: filters.to
+    });
+    const searchDir = filters.workspace ? join5(this.baseDir, filters.workspace) : this.baseDir;
+    const files = globMarkdown(searchDir);
+    const entries = [];
+    for (const file of files) {
+      const { frontmatter: fm, body } = readEntry(file);
+      const date = String(fm.date || "");
+      if (!date) continue;
+      if (from && date < from.split("T")[0]) continue;
+      if (to && date > to.split("T")[0]) continue;
+      entries.push({
+        type: fm.type || "note",
+        date,
+        workspace: String(fm.workspace || "default"),
+        project: String(fm.project || "global"),
+        summary: body.slice(0, 100).replace(/\n/g, " ")
+      });
+    }
+    return entries.sort((a, b) => b.date.localeCompare(a.date));
+  }
+  // ── Topics ──
+  getTopics() {
+    const files = globMarkdown(this.baseDir);
+    const topicSet = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const { frontmatter: fm } = readEntry(file);
+      if (fm.topic) {
+        const name = String(fm.topic);
+        topicSet.set(name, (topicSet.get(name) || 0) + 1);
+      }
+    }
+    return Array.from(topicSet.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([name]) => ({
+      id: name,
+      name,
+      description: null,
+      is_custom: true
+    }));
+  }
+  insertTopic(name, _description) {
+    return {
+      id: name,
+      name,
+      description: _description || null,
+      is_custom: true
+    };
+  }
+  // ── Code TODOs ──
+  getCodeTodos(repoPath) {
+    return scanCodeTodos(repoPath);
+  }
+  syncCodeTodos(_repoPath, _todos) {
+    return { added: 0, resolved: 0 };
+  }
+  // ── Private helpers ──
+  projectDir(ws) {
+    return join5(this.baseDir, ws.workspace, ws.project);
+  }
+  typeDir(ws, type) {
+    const dir = join5(this.projectDir(ws), TYPE_FOLDERS[type]);
+    ensureDir(dir);
+    return dir;
+  }
+  findFileById(dir, id) {
+    const direct = join5(dir, `${id}.md`);
+    if (existsSync4(direct)) return direct;
+    const files = globMarkdown(dir);
+    for (const file of files) {
+      if (extractIdFromFilename(basename5(file)) === id) return file;
+    }
+    return null;
+  }
+  extractTodoContent(body) {
+    const match = body.match(/^- \[[ x]\] (.+?)(?:\s*[\u23EB\uD83D\uDD3C\uD83D\uDD3D\uD83D\uDCC5\u2705].*)?$/m);
+    return match ? match[1].trim() : body.trim();
+  }
+  filterAndMap(files, filters, mapper) {
+    const results = [];
+    for (const file of files) {
+      const { frontmatter: fm, body } = readEntry(file);
+      const date = String(fm.date || "");
+      if (filters.from && date < filters.from) continue;
+      if (filters.to && date > filters.to) continue;
+      if (filters.topicId && fm.topic !== filters.topicId) continue;
+      const id = extractIdFromFilename(basename5(file));
+      results.push(mapper(fm, body, id));
+    }
+    results.sort((a, b) => {
+      const dateA = a.date || "";
+      const dateB = b.date || "";
+      return dateB.localeCompare(dateA);
+    });
+    const limit = filters.limit ?? 100;
+    return results.slice(0, limit);
+  }
+  groupByProject(items) {
+    const map = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const key = item.project || "global";
+      if (!map.has(key)) map.set(key, []);
+      map.get(key).push(item);
+    }
+    return Array.from(map.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([name, reminders]) => ({
+      repo_name: name === "global" ? null : name,
+      reminders
+    }));
+  }
+  resolveDates(filters) {
+    if (filters.from || filters.to) {
+      return { from: filters.from, to: filters.to };
+    }
+    const now = /* @__PURE__ */ new Date();
+    const today = todayDate2();
+    switch (filters.period) {
+      case "today":
+        return { from: today, to: today };
+      case "yesterday": {
+        const yesterday = new Date(now.getTime() - 864e5).toISOString().split("T")[0];
+        return { from: yesterday, to: yesterday };
+      }
+      case "week": {
+        const weekAgo = new Date(now.getTime() - 7 * 864e5).toISOString().split("T")[0];
+        return { from: weekAgo, to: today };
+      }
+      case "month": {
+        const monthAgo = new Date(now.getTime() - 30 * 864e5).toISOString().split("T")[0];
+        return { from: monthAgo, to: today };
+      }
+      default:
+        return { from: today, to: today };
+    }
+  }
+};
+
+// src/storage/index.ts
+var VALID_MODES = ["sqlite", "obsidian"];
+var instance = null;
+function getStorageMode() {
+  const mode = process.env.LOGBOOK_STORAGE?.toLowerCase();
+  if (!mode) return "sqlite";
+  if (mode === "obsidian") return "obsidian";
+  if (mode === "sqlite") return "sqlite";
+  throw new Error(
+    `LOGBOOK_STORAGE invalido: "${mode}". Valores validos: ${VALID_MODES.join(", ")}`
+  );
+}
+function getStorage() {
+  if (instance) return instance;
+  const mode = getStorageMode();
+  if (mode === "obsidian") {
+    const dir = process.env.LOGBOOK_DIR;
+    if (!dir) {
+      throw new Error(
+        "LOGBOOK_DIR es requerido cuando LOGBOOK_STORAGE=obsidian. Debe apuntar a la carpeta del vault de Obsidian."
+      );
+    }
+    instance = new ObsidianStorage(dir);
+  } else {
+    instance = new SqliteStorage();
+  }
+  return instance;
+}
+
+// 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().min(1).max(50).regex(/^[a-z0-9-]+$/, "Solo letras minusculas, numeros y guiones").optional().describe("Nombre del nuevo tema (solo para action=add, lowercase, sin espacios)"),
+      description: z.string().max(200).optional().describe("Descripcion del nuevo tema (solo para action=add)")
+    },
+    async ({ action, name, description }) => {
+      try {
+        const storage = getStorage();
+        if (action === "add") {
+          if (!name) {
+            return {
+              isError: true,
+              content: [{ type: "text", text: 'El parametro "name" es obligatorio para action=add' }]
+            };
+          }
+          const topics2 = storage.getTopics();
+          if (topics2.some((t) => t.name === name)) {
+            return {
+              isError: true,
+              content: [{ type: "text", text: `El topic "${name}" ya existe` }]
+            };
+          }
+          const topic = storage.insertTopic(name, description);
+          return {
+            content: [{ type: "text", text: JSON.stringify(topic) }]
+          };
+        }
+        const topics = storage.getTopics();
+        return {
+          content: [{ type: "text", text: JSON.stringify(topics) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/note.ts
+import { z as z2 } from "zod";
+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().min(1).max(5e3).describe("Contenido de la nota"),
+      topic: z2.string().optional().describe("Topic: feature, fix, chore, idea, decision, blocker (o custom)")
+    },
+    async ({ content, topic }) => {
+      try {
+        const storage = getStorage();
+        storage.autoRegisterRepo();
+        const note = storage.insertNote(content, topic);
+        return {
+          content: [{ type: "text", text: JSON.stringify(note) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error creando nota: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// 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().min(1).max(2e3).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"),
+      remind_at: z3.string().optional().describe("Fecha recordatorio unica (YYYY-MM-DD)"),
+      remind_pattern: z3.string().optional().describe("Patron recurrente: daily, weekdays, weekly:2 (martes), weekly:1,3 (lun+mie), monthly:1 (dia 1), monthly:1,15"),
+      items: z3.array(
+        z3.object({
+          content: z3.string().min(1).max(2e3).describe("Contenido del TODO"),
+          topic: z3.string().optional().describe("Topic"),
+          priority: priorityEnum.optional().default("normal").describe("Prioridad"),
+          remind_at: z3.string().optional().describe("Fecha recordatorio (YYYY-MM-DD)"),
+          remind_pattern: z3.string().optional().describe("Patron recurrente")
+        })
+      ).max(50).optional().describe("Array de TODOs para crear varios a la vez (max 50)")
+    },
+    async ({ content, topic, priority, remind_at, remind_pattern, 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 storage = getStorage();
+        storage.autoRegisterRepo();
+        const todoItems = items ? items : [{ content, topic, priority: priority ?? "normal", remind_at, remind_pattern }];
+        const results = [];
+        for (const item of todoItems) {
+          const hasReminder = item.remind_at || item.remind_pattern;
+          const effectiveTopic = hasReminder && !item.topic ? "reminder" : item.topic;
+          const todo = storage.insertTodo(item.content, {
+            topic: effectiveTopic,
+            priority: item.priority ?? "normal",
+            remind_at: item.remind_at,
+            remind_pattern: item.remind_pattern
+          });
+          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 instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/todo-list.ts
+import { z as z4 } from "zod";
+function registerTodoListTool(server) {
+  server.tool(
+    "logbook_todo_list",
+    "Lista TODOs agrupados por topic. Incluye manuales y del codigo (TODO/FIXME/HACK/BUG). Sincroniza automaticamente: code TODOs que desaparecen del codigo se marcan como resueltos.",
+    {
+      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 storage = getStorage();
+        if (scope === "project") storage.autoRegisterRepo();
+        const manualTodos = source === "code" ? [] : storage.getTodos({
+          status,
+          topicId: topic,
+          priority,
+          from,
+          to,
+          limit
+        });
+        let codeTodos = [];
+        let syncResult = null;
+        if (source !== "manual" && status !== "done") {
+          const repoPath = scope === "project" ? detectRepoPath() : null;
+          if (repoPath) {
+            codeTodos = storage.getCodeTodos(repoPath);
+            syncResult = storage.syncCodeTodos(repoPath, codeTodos);
+            if (topic) {
+              codeTodos = codeTodos.filter((ct) => ct.topic_name === topic);
+            }
+          }
+        }
+        const groupMap = /* @__PURE__ */ new Map();
+        for (const todo of manualTodos) {
+          const key = todo.topic ?? "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,
+                ...syncResult && (syncResult.added > 0 || syncResult.resolved > 0) ? { sync: syncResult } : {}
+              }
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error listando TODOs: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// 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). Los recordatorios recurrentes se marcan como hechos por hoy y vuelven automaticamente el proximo dia que toque.",
+    {
+      ids: z5.union([z5.number(), z5.string(), z5.array(z5.union([z5.number(), z5.string()]))]).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 storage = getStorage();
+        storage.autoRegisterRepo();
+        const idArray = (Array.isArray(ids) ? ids : [ids]).map(String);
+        const allTodos = storage.getTodos({ status: "all" });
+        const todoMap = new Map(allTodos.map((t) => [t.id, t]));
+        const regularIds = [];
+        const recurringIds = [];
+        for (const id of idArray) {
+          const todo = todoMap.get(id);
+          if (todo?.remind_pattern && !undo) {
+            recurringIds.push(id);
+          } else {
+            regularIds.push(id);
+          }
+        }
+        const results = [];
+        if (regularIds.length > 0) {
+          const status = undo ? "pending" : "done";
+          const updated = storage.updateTodoStatus(regularIds, status);
+          results.push(...updated);
+        }
+        for (const id of recurringIds) {
+          storage.ackRecurringReminder(id);
+          const todo = todoMap.get(id);
+          if (todo) results.push(todo);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              action: undo ? "undo" : "done",
+              updated: results.length,
+              recurring_acked: recurringIds.length,
+              todos: results
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// 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.union([z6.number(), z6.string()]).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 storage = getStorage();
+        storage.autoRegisterRepo();
+        const updated = storage.updateTodo(String(id), { content, topic, 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 instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// 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.string(), z7.array(z7.union([z7.number(), z7.string()]))]).describe("ID o array de IDs de TODOs a eliminar")
+    },
+    async ({ ids }) => {
+      try {
+        const storage = getStorage();
+        storage.autoRegisterRepo();
+        const idArray = (Array.isArray(ids) ? ids : [ids]).map(String);
+        const deleted = storage.deleteTodos(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 instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// 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 storage = getStorage();
+        const repo = scope === "project" ? storage.autoRegisterRepo() : null;
+        const entries = storage.getLog({
+          period,
+          from,
+          to,
+          type,
+          topic,
+          scope
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              period: from ? `${from} \u2014 ${to || from}` : period ?? "today",
+              scope: scope ?? "project",
+              project: repo?.name ?? null,
+              entries,
+              summary: {
+                total: entries.length
+              }
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// 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().min(1).max(500).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 storage = getStorage();
+        if (scope === "project") storage.autoRegisterRepo();
+        const results = storage.search(query, { type, topic, scope, limit });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              query,
+              results,
+              total: results.length
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error buscando: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/standup.ts
+import { z as z10 } from "zod";
+function registerStandupTool(server) {
+  server.tool(
+    "logbook_standup",
+    "Registra un standup diario con lo que se hizo ayer, lo de hoy y blockers. Ideal para Daily Notes en Obsidian.",
+    {
+      yesterday: z10.string().min(1).max(2e3).describe("Lo que se hizo ayer"),
+      today: z10.string().min(1).max(2e3).describe("Lo que se va a hacer hoy"),
+      blockers: z10.string().max(2e3).optional().default("").describe("Blockers actuales (opcional)"),
+      topic: z10.string().optional().describe("Topic (opcional)")
+    },
+    async ({ yesterday, today, blockers, topic }) => {
+      try {
+        const storage = getStorage();
+        storage.autoRegisterRepo();
+        const standup = storage.insertStandup(yesterday, today, blockers, topic);
+        return {
+          content: [{ type: "text", text: JSON.stringify(standup) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error creando standup: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/decision.ts
+import { z as z11 } from "zod";
+function registerDecisionTool(server) {
+  server.tool(
+    "logbook_decision",
+    "Registra una decision arquitectonica o tecnica (ADR). Incluye contexto, opciones, decision y consecuencias.",
+    {
+      title: z11.string().min(1).max(200).describe("Titulo de la decision"),
+      context: z11.string().min(1).max(3e3).describe("Contexto: por que se necesita esta decision"),
+      options: z11.array(z11.string().min(1).max(500)).min(1).max(10).describe("Opciones consideradas"),
+      decision: z11.string().min(1).max(2e3).describe("Decision tomada"),
+      consequences: z11.string().min(1).max(2e3).describe("Consecuencias de la decision"),
+      topic: z11.string().optional().describe("Topic (default: decision)")
+    },
+    async ({ title, context, options, decision, consequences, topic }) => {
+      try {
+        const storage = getStorage();
+        storage.autoRegisterRepo();
+        const entry = storage.insertDecision(title, context, options, decision, consequences, topic);
+        return {
+          content: [{ type: "text", text: JSON.stringify(entry) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error creando decision: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/debug.ts
+import { z as z12 } from "zod";
+function registerDebugTool(server) {
+  server.tool(
+    "logbook_debug",
+    "Registra una sesion de debug: error, causa, fix y archivo adjunto opcional. En Obsidian se muestra como callout [!bug].",
+    {
+      title: z12.string().min(1).max(200).describe("Titulo del bug/error"),
+      error: z12.string().min(1).max(3e3).describe("Descripcion del error"),
+      cause: z12.string().min(1).max(3e3).describe("Causa raiz identificada"),
+      fix: z12.string().min(1).max(3e3).describe("Solucion aplicada"),
+      file: z12.string().optional().describe("Ruta a archivo adjunto (screenshot, log). Se copia al vault."),
+      topic: z12.string().optional().describe("Topic (default: fix)")
+    },
+    async ({ title, error, cause, fix, file, topic }) => {
+      try {
+        const storage = getStorage();
+        storage.autoRegisterRepo();
+        const entry = storage.insertDebug(title, error, cause, fix, file, topic);
+        return {
+          content: [{ type: "text", text: JSON.stringify(entry) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error creando debug entry: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/tags.ts
+import { z as z13 } from "zod";
+function registerTagsTool(server) {
+  server.tool(
+    "logbook_tags",
+    "Lista todos los tags usados en el logbook con su conteo. Opcionalmente filtra por un tag especifico.",
+    {
+      filter: z13.string().optional().describe("Filtrar por tag especifico (opcional)")
+    },
+    async ({ filter }) => {
+      try {
+        const storage = getStorage();
+        storage.autoRegisterRepo();
+        const tags = storage.getTags(filter);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ tags, total: tags.length }) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error listando tags: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/timeline.ts
+import { z as z14 } from "zod";
+function registerTimelineTool(server) {
+  server.tool(
+    "logbook_timeline",
+    "Timeline de actividad cruzando proyectos y workspaces. Muestra un resumen cronologico de toda la actividad.",
+    {
+      period: z14.enum(["today", "yesterday", "week", "month"]).optional().default("week").describe("Periodo (default: week)"),
+      from: z14.string().optional().describe("Desde fecha (YYYY-MM-DD). Sobreescribe period."),
+      to: z14.string().optional().describe("Hasta fecha (YYYY-MM-DD). Sobreescribe period."),
+      workspace: z14.string().optional().describe("Filtrar por workspace (opcional)")
+    },
+    async ({ period, from, to, workspace }) => {
+      try {
+        const storage = getStorage();
+        storage.autoRegisterRepo();
+        const entries = storage.getTimeline({ period, from, to, workspace });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              period: from ? `${from} \u2014 ${to || from}` : period,
+              entries,
+              total: entries.length
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error generando timeline: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/migrate.ts
+function registerMigrateTool(server) {
+  server.tool(
+    "logbook_migrate",
+    "Convierte datos existentes de SQLite a archivos markdown para Obsidian. Requiere LOGBOOK_STORAGE=obsidian y que exista la base de datos SQLite.",
+    {},
+    async () => {
+      try {
+        if (getStorageMode() !== "obsidian") {
+          return {
+            isError: true,
+            content: [{
+              type: "text",
+              text: "logbook_migrate requiere LOGBOOK_STORAGE=obsidian. Configura las variables de entorno antes de migrar."
+            }]
+          };
+        }
+        let db2;
+        try {
+          db2 = getDb();
+        } catch {
+          return {
+            isError: true,
+            content: [{
+              type: "text",
+              text: "No se encontro la base de datos SQLite en ~/.logbook/logbook.db"
+            }]
+          };
+        }
+        const notes = getNotes(db2, { limit: 1e4 });
+        const todos = getTodos(db2, { limit: 1e4 });
+        const storage = getStorage();
+        storage.autoRegisterRepo();
+        let migratedNotes = 0;
+        let migratedTodos = 0;
+        for (const note of notes) {
+          try {
+            storage.insertNote(note.content, note.topic_name || void 0);
+            migratedNotes++;
+          } catch {
+          }
+        }
+        for (const todo of todos) {
+          try {
+            const entry = storage.insertTodo(todo.content, {
+              topic: todo.topic_name || void 0,
+              priority: todo.priority,
+              remind_at: todo.remind_at || void 0,
+              remind_pattern: todo.remind_pattern || void 0
+            });
+            if (todo.status === "done") {
+              storage.updateTodoStatus([entry.id], "done");
+            }
+            migratedTodos++;
+          } catch {
+          }
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              migrated: {
+                notes: migratedNotes,
+                todos: migratedTodos,
+                total: migratedNotes + migratedTodos
+              },
+              source: "sqlite (~/.logbook/logbook.db)",
+              destination: process.env.LOGBOOK_DIR
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error migrando: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/reminders.ts
+function registerRemindersResource(server) {
+  server.resource(
+    "reminders",
+    "logbook://reminders",
+    {
+      description: "Recordatorios pendientes para hoy y atrasados, agrupados por proyecto. Vacio si no hay ninguno.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      try {
+        const storage = getStorage();
+        storage.autoRegisterRepo();
+        const result = storage.getDueReminders();
+        if (!result) {
+          return { contents: [] };
+        }
+        for (const group of result.recurring) {
+          for (const reminder of group.reminders) {
+            storage.ackRecurringReminder(reminder.id);
+          }
+        }
+        return {
+          contents: [{
+            uri: uri.href,
+            text: JSON.stringify(result)
+          }]
+        };
+      } catch {
+        return { contents: [] };
+      }
+    }
+  );
+}
+
+// src/server.ts
+var VERSION = true ? "0.5.1" : "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);
+  registerStandupTool(server);
+  registerDecisionTool(server);
+  registerDebugTool(server);
+  registerTagsTool(server);
+  registerTimelineTool(server);
+  registerMigrateTool(server);
+  registerRemindersResource(server);
+  return server;
+}
+export {
+  createServer
+};