fathom-mcp 0.4.8 → 0.4.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fathom-mcp",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "MCP server for Fathom — vault operations, search, rooms, and cross-workspace communication",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -91,6 +91,25 @@ function appendToGitignore(dir, patterns) {
   }
 }
 
+/**
+ * Idempotently register a hook in a settings object.
+ * Works for both Claude Code and Gemini CLI (same JSON structure).
+ * Returns true if a new hook was added, false if already present.
+ */
+function ensureHook(settings, eventName, command, timeout) {
+  const existing = settings.hooks?.[eventName] || [];
+  const alreadyRegistered = existing.some((entry) =>
+    entry.hooks?.some((h) => h.command === command)
+  );
+  if (alreadyRegistered) return false;
+  if (!settings.hooks) settings.hooks = {};
+  settings.hooks[eventName] = [
+    ...existing,
+    { hooks: [{ type: "command", command, timeout }] },
+  ];
+  return true;
+}
+
 function copyScripts(targetDir) {
   fs.mkdirSync(targetDir, { recursive: true });
   try {
@@ -446,17 +465,19 @@ async function runInit(flags = {}) {
     ? (nonInteractive ? "vault" : await ask(rl, "  Vault subdirectory", "vault"))
     : "vault";
 
-  // 9. Hooks — only ask if Claude Code is selected
+  // 9. Hooks — ask if any hook-supporting agent is selected (Claude Code, Gemini CLI)
   const hasClaude = selectedAgents.includes("claude-code");
+  const hasGemini = selectedAgents.includes("gemini");
+  const hasHookAgent = hasClaude || hasGemini;
   let enableRecallHook = false;
   let enablePrecompactHook = false;
-  if (hasClaude) {
+  if (hasHookAgent) {
     if (nonInteractive) {
       enableRecallHook = true;
       enablePrecompactHook = true;
     } else {
       console.log();
-      enableRecallHook = await askYesNo(rl, "  Enable vault recall on every message (UserPromptSubmit)?", true);
+      enableRecallHook = await askYesNo(rl, "  Enable vault recall on every message?", true);
       enablePrecompactHook = await askYesNo(rl, "  Enable PreCompact vault snapshot hook?", true);
     }
   }
@@ -531,60 +552,34 @@ async function runInit(flags = {}) {
     console.log(`  ✓ ${result}`);
   }
 
-  // Claude Code hooks — only if claude-code is selected
-  if (hasClaude) {
-    const claudeSettingsPath = path.join(cwd, ".claude", "settings.local.json");
-    const claudeSettings = readJsonFile(claudeSettingsPath) || {};
-
-    const hooks = {};
-
-    // SessionStart — always registered (version check should always be on)
-    hooks["SessionStart"] = [
-      ...(claudeSettings.hooks?.["SessionStart"] || []),
-    ];
-    const sessionStartCmd = "bash .fathom/scripts/fathom-sessionstart.sh";
-    const hasFathomSessionStart = hooks["SessionStart"].some((entry) =>
-      entry.hooks?.some((h) => h.command === sessionStartCmd)
-    );
-    if (!hasFathomSessionStart) {
-      hooks["SessionStart"].push({
-        hooks: [{ type: "command", command: sessionStartCmd, timeout: 10000 }],
-      });
-    }
+  // Hook scripts (shared across agents)
+  const sessionStartCmd = "bash .fathom/scripts/fathom-sessionstart.sh";
+  const recallCmd = "bash .fathom/scripts/fathom-recall.sh";
+  const precompactCmd = "bash .fathom/scripts/fathom-precompact.sh";
 
-    if (enableRecallHook) {
-      hooks["UserPromptSubmit"] = [
-        ...(claudeSettings.hooks?.["UserPromptSubmit"] || []),
-      ];
-      const recallCmd = "bash .fathom/scripts/fathom-recall.sh";
-      const hasFathomRecall = hooks["UserPromptSubmit"].some((entry) =>
-        entry.hooks?.some((h) => h.command === recallCmd)
-      );
-      if (!hasFathomRecall) {
-        hooks["UserPromptSubmit"].push({
-          hooks: [{ type: "command", command: recallCmd, timeout: 10000 }],
-        });
-      }
-    }
-    if (enablePrecompactHook) {
-      hooks["PreCompact"] = [
-        ...(claudeSettings.hooks?.["PreCompact"] || []),
-      ];
-      const precompactCmd = "bash .fathom/scripts/fathom-precompact.sh";
-      const hasFathomPrecompact = hooks["PreCompact"].some((entry) =>
-        entry.hooks?.some((h) => h.command === precompactCmd)
-      );
-      if (!hasFathomPrecompact) {
-        hooks["PreCompact"].push({
-          hooks: [{ type: "command", command: precompactCmd, timeout: 30000 }],
-        });
-      }
+  // Claude Code hooks
+  if (hasClaude) {
+    const settingsPath = path.join(cwd, ".claude", "settings.local.json");
+    const settings = readJsonFile(settingsPath) || {};
+    let changed = ensureHook(settings, "SessionStart", sessionStartCmd, 10000);
+    if (enableRecallHook) changed = ensureHook(settings, "UserPromptSubmit", recallCmd, 10000) || changed;
+    if (enablePrecompactHook) changed = ensureHook(settings, "PreCompact", precompactCmd, 30000) || changed;
+    if (changed) {
+      writeJsonFile(settingsPath, settings);
+      console.log("  ✓ .claude/settings.local.json (hooks)");
     }
+  }
 
-    if (Object.keys(hooks).length > 0) {
-      claudeSettings.hooks = { ...(claudeSettings.hooks || {}), ...hooks };
-      writeJsonFile(claudeSettingsPath, claudeSettings);
-      console.log("  ✓ .claude/settings.local.json (hooks)");
+  // Gemini CLI hooks
+  if (hasGemini) {
+    const settingsPath = path.join(cwd, ".gemini", "settings.json");
+    const settings = readJsonFile(settingsPath) || {};
+    let changed = ensureHook(settings, "SessionStart", sessionStartCmd, 10000);
+    if (enableRecallHook) changed = ensureHook(settings, "BeforeAgent", recallCmd, 10000) || changed;
+    if (enablePrecompactHook) changed = ensureHook(settings, "PreCompress", precompactCmd, 30000) || changed;
+    if (changed) {
+      writeJsonFile(settingsPath, settings);
+      console.log("  ✓ .gemini/settings.json (hooks)");
     }
   }
 
@@ -784,27 +779,33 @@ async function runUpdate() {
   fs.mkdirSync(fathomDir, { recursive: true });
   fs.writeFileSync(path.join(fathomDir, "version"), packageVersion + "\n");
 
-  // Ensure SessionStart hook is registered for Claude Code workspaces
-  // Detect by .claude/ dir (older configs may not have agents field)
-  const hasClaude = (found.config.agents || []).includes("claude-code")
+  // Ensure SessionStart hook is registered for agents that support hooks
+  // Detect by config agents field or directory presence (older configs may lack agents)
+  const agents = found.config.agents || [];
+  const sessionStartCmd = "bash .fathom/scripts/fathom-sessionstart.sh";
+  const registeredHooks = [];
+
+  // Claude Code
+  const hasClaude = agents.includes("claude-code")
     || fs.existsSync(path.join(projectDir, ".claude"));
-  let hooksUpdated = false;
   if (hasClaude) {
-    const claudeSettingsPath = path.join(projectDir, ".claude", "settings.local.json");
-    const claudeSettings = readJsonFile(claudeSettingsPath) || {};
-    const sessionStartCmd = "bash .fathom/scripts/fathom-sessionstart.sh";
-    const existingHooks = claudeSettings.hooks?.["SessionStart"] || [];
-    const hasSessionStart = existingHooks.some((entry) =>
-      entry.hooks?.some((h) => h.command === sessionStartCmd)
-    );
-    if (!hasSessionStart) {
-      claudeSettings.hooks = claudeSettings.hooks || {};
-      claudeSettings.hooks["SessionStart"] = [
-        ...existingHooks,
-        { hooks: [{ type: "command", command: sessionStartCmd, timeout: 10000 }] },
-      ];
-      writeJsonFile(claudeSettingsPath, claudeSettings);
-      hooksUpdated = true;
+    const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
+    const settings = readJsonFile(settingsPath) || {};
+    if (ensureHook(settings, "SessionStart", sessionStartCmd, 10000)) {
+      writeJsonFile(settingsPath, settings);
+      registeredHooks.push("Claude Code → .claude/settings.local.json");
+    }
+  }
+
+  // Gemini CLI
+  const hasGemini = agents.includes("gemini")
+    || fs.existsSync(path.join(projectDir, ".gemini"));
+  if (hasGemini) {
+    const settingsPath = path.join(projectDir, ".gemini", "settings.json");
+    const settings = readJsonFile(settingsPath) || {};
+    if (ensureHook(settings, "SessionStart", sessionStartCmd, 10000)) {
+      writeJsonFile(settingsPath, settings);
+      registeredHooks.push("Gemini CLI → .gemini/settings.json");
     }
   }
 
@@ -817,9 +818,11 @@ async function runUpdate() {
     }
   }
 
-  if (hooksUpdated) {
-    console.log("\n  Registered hooks:");
-    console.log("    SessionStart → fathom-sessionstart.sh (version check)");
+  if (registeredHooks.length > 0) {
+    console.log("\n  Registered SessionStart hooks:");
+    for (const hook of registeredHooks) {
+      console.log(`    ${hook}`);
+    }
   }
 
   console.log(`\n  Version written to .fathom/version`);

package/src/index.js

@@ -291,6 +291,55 @@ const tools = [
       required: ["workspace", "message"],
     },
   },
+  {
+    name: "fathom_routine_create",
+    description:
+      "Create a new ping routine for a workspace. Routines fire on an interval and inject " +
+      "context into the persistent session. Use single_fire for one-shot routines that " +
+      "auto-disable after firing once. All parameters are optional with sensible defaults.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Routine name. Default: 'New Routine'." },
+        enabled: { type: "boolean", description: "Start enabled. Default: false." },
+        interval_minutes: { type: "integer", description: "Minutes between pings. Default: 60.", minimum: 1 },
+        single_fire: { type: "boolean", description: "Auto-disable after firing once. Default: false." },
+        workspace: WORKSPACE_PROP,
+        context_sources: {
+          type: "object",
+          description: "What to inject on each ping.",
+          properties: {
+            time: { type: "boolean", description: "Include current time/date. Default: true." },
+            scripts: {
+              type: "array",
+              description: "Shell commands to run and inject output.",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string" },
+                  command: { type: "string" },
+                  enabled: { type: "boolean" },
+                },
+              },
+            },
+            texts: {
+              type: "array",
+              description: "Static text blocks to inject.",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string" },
+                  content: { type: "string" },
+                  enabled: { type: "boolean" },
+                },
+              },
+            },
+          },
+        },
+      },
+      required: [],
+    },
+  },
 ];
 
 // --- Vault routing by mode ---------------------------------------------------
@@ -480,6 +529,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     case "fathom_send":
       result = await client.sendToWorkspace(args.workspace, args.message, config.workspace);
       break;
+    case "fathom_routine_create": {
+      const routineParams = {};
+      if (args.name != null) routineParams.name = args.name;
+      if (args.enabled != null) routineParams.enabled = args.enabled;
+      if (args.interval_minutes != null) routineParams.intervalMinutes = args.interval_minutes;
+      if (args.single_fire != null) routineParams.singleFire = args.single_fire;
+      if (args.context_sources != null) routineParams.contextSources = args.context_sources;
+      result = await client.createRoutine(routineParams, args.workspace || config.workspace);
+      break;
+    }
     default:
       result = { error: `Unknown tool: ${name}` };
   }
@@ -539,6 +598,13 @@ async function startupSync() {
         await client.pushFile(config.workspace, filePath, content);
       }
     }
+
+    // Delete server files that no longer exist locally (local is source of truth)
+    if (diff.deleted?.length) {
+      for (const filePath of diff.deleted) {
+        await client.deleteFile(config.workspace, filePath);
+      }
+    }
   } catch {
     // Sync failure is non-fatal — local vault is source of truth
   }
@@ -551,6 +617,7 @@ async function main() {
       vault: config._rawVault,
       description: config.description,
       agents: config.agents,
+      type: config.vaultMode,
     }).catch(() => {});
   }
 

package/src/server-client.js

@@ -190,6 +190,21 @@ export function createClient(config) {
     });
   }
 
+  // --- Activation / Routines -------------------------------------------------
+
+  async function createRoutine(params, ws) {
+    const body = {};
+    if (params.name != null) body.name = params.name;
+    if (params.enabled != null) body.enabled = params.enabled;
+    if (params.intervalMinutes != null) body.intervalMinutes = params.intervalMinutes;
+    if (params.singleFire != null) body.singleFire = params.singleFire;
+    if (params.contextSources != null) body.contextSources = params.contextSources;
+    return request("POST", "/api/activation/ping/routines", {
+      params: { workspace: ws },
+      body,
+    });
+  }
+
   // --- Auth ------------------------------------------------------------------
 
   async function getApiKey() {
@@ -229,6 +244,7 @@ export function createClient(config) {
     listFiles,
     pushFile,
     syncManifest,
+    createRoutine,
     getApiKey,
     healthCheck,
   };