@everstateai/mcp 1.3.12 → 1.3.14

package/src/setup/hooks/templates.ts

@@ -21,9 +21,13 @@ export function getSyncTodosHook(config?: Partial<HookConfig>): string {
  * VERSION: ${HOOK_VERSIONS.syncTodos}
  * GENERATED: ${generatedAt}
  *
- * Syncs Claude's TodoWrite tasks with Everstate.
+ * Two-way sync between Claude's TodoWrite and Everstate dashboard.
  * Runs after every TodoWrite tool call.
  *
+ * Push: Sends Claude's todos to Everstate for matching and storage.
+ * Pull: Reads dashboard changes from API response and outputs instructions
+ *       to stdout so Claude can update its TodoWrite list.
+ *
  * Claude Code passes hook data via STDIN as JSON:
  * { "tool_name": "TodoWrite", "tool_input": { "todos": [...] }, ... }
  */
@@ -88,6 +92,19 @@ async function main() {
       process.exit(0);
     }
 
+    // Read last sync timestamp for two-way sync
+    const syncStatePath = path.join(
+      process.env.CLAUDE_PROJECT_DIR || process.cwd(),
+      '.claude', '.sync-state.json'
+    );
+    let lastSyncedAt = null;
+    try {
+      if (fs.existsSync(syncStatePath)) {
+        const state = JSON.parse(fs.readFileSync(syncStatePath, 'utf8'));
+        lastSyncedAt = state.lastSyncedAt || null;
+      }
+    } catch {}
+
     // Send to API for matching and storage
     const response = await fetch(\`\${API_URL}/api/session/sync-todos\`, {
       method: 'POST',
@@ -99,12 +116,47 @@ async function main() {
         projectId,
         todos,
         sessionId: process.env.SESSION_ID || null,
+        lastSyncedAt,
       }),
     });
 
     if (!response.ok) {
       const text = await response.text();
       console.error('[everstate] Sync failed:', response.status, text);
+      process.exit(0);
+    }
+
+    // Parse response for two-way sync
+    const data = await response.json();
+
+    // Save sync timestamp for next run
+    try {
+      fs.mkdirSync(path.dirname(syncStatePath), { recursive: true });
+      fs.writeFileSync(syncStatePath, JSON.stringify({
+        lastSyncedAt: data.syncedAt || new Date().toISOString(),
+      }));
+    } catch {}
+
+    // Output dashboard changes to stdout (Claude sees this)
+    const changes = data.dashboardChanges || [];
+    if (changes.length > 0) {
+      const lines = [];
+      for (const c of changes) {
+        if (c.type === 'status_changed') {
+          lines.push('- "' + c.taskTitle + '" was changed to ' + c.newValue + ' on the dashboard');
+        } else if (c.type === 'deleted') {
+          lines.push('- "' + c.taskTitle + '" was deleted on the dashboard');
+        } else if (c.type === 'title_changed') {
+          lines.push('- "' + c.oldValue + '" was renamed to "' + c.newValue + '" on the dashboard');
+        }
+      }
+      if (lines.length > 0) {
+        console.log('');
+        console.log('[Everstate] Dashboard changes detected since last sync:');
+        console.log(lines.join('\\n'));
+        console.log('');
+        console.log('Please update your TodoWrite list to reflect these changes.');
+      }
     }
   } catch (error) {
     console.error('[everstate] Hook error:', error.message);
@@ -153,7 +205,8 @@ export function getSessionEndHook(config?: Partial<HookConfig>): string {
 # VERSION: ${HOOK_VERSIONS.sessionEnd}
 # GENERATED: ${generatedAt}
 #
-# Saves session summary when Claude session ends.
+# Auto-saves session when Claude session ends.
+# Calls auto-done which generates summary from tracked activity.
 
 API_KEY_PATH="${apiKeyPath}"
 API_URL="${apiUrl}"
@@ -182,8 +235,8 @@ if [ -z "$PROJECT_ID" ]; then
   exit 0
 fi
 
-# Signal session end to API
-curl -s -X POST "$API_URL/api/session/end" \\
+# Call auto-done (generates summary from activity, skips if done() was already called)
+curl -s -X POST "$API_URL/api/session/auto-done" \\
   -H "Content-Type: application/json" \\
   -H "Authorization: Bearer $API_KEY" \\
   -d "{\\"projectId\\": \\"$PROJECT_ID\\"}" > /dev/null 2>&1
@@ -193,57 +246,358 @@ exit 0
 }
 
 /**
- * Get the pre-compact.sh hook content (for context compaction)
+ * Get the pre-compact.js hook content
+ * Prints critical Everstate memory to stdout so it survives compaction.
  */
 export function getPreCompactHook(config?: Partial<HookConfig>): string {
   const apiKeyPath = config?.apiKeyPath || `${getEverstateDir()}/api-key`;
   const apiUrl = config?.apiUrl || EVERSTATE_API_URL;
   const generatedAt = config?.generatedAt || new Date().toISOString();
 
-  return `#!/bin/bash
-# Everstate Pre-Compact Hook v${HOOK_VERSIONS.sessionEnd}
-# VERSION: ${HOOK_VERSIONS.sessionEnd}
-# GENERATED: ${generatedAt}
-#
-# Saves session context before Claude's context compaction.
+  return getContextInjectionHook({
+    hookName: 'Pre-Compact',
+    version: HOOK_VERSIONS.preCompact,
+    generatedAt,
+    apiKeyPath,
+    apiUrl,
+    preamble: 'Critical context preserved through compaction',
+    timeout: 8000,
+    includeBlockers: true,
+    includeTasks: true,
+    maxGotchas: 5,
+    maxDecisions: 5,
+    postAction: `
+    fetch(\\\`\\\${API_URL}/api/session/compact-warning\\\`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': \\\`Bearer \\\${apiKey}\\\` },
+      body: JSON.stringify({ projectId, message: 'Context compacted — critical context re-injected' }),
+    }).catch(() => {});`,
+  });
+}
 
-API_KEY_PATH="${apiKeyPath}"
-API_URL="${apiUrl}"
+/**
+ * Get the subagent-context.js hook content
+ * Injects critical context when subagents spawn.
+ */
+export function getSubagentContextHook(config?: Partial<HookConfig>): string {
+  const apiKeyPath = config?.apiKeyPath || `${getEverstateDir()}/api-key`;
+  const apiUrl = config?.apiUrl || EVERSTATE_API_URL;
+  const generatedAt = config?.generatedAt || new Date().toISOString();
 
-# Read API key
-if [ ! -f "$API_KEY_PATH" ]; then
-  exit 0
-fi
-API_KEY=$(cat "$API_KEY_PATH")
+  return getContextInjectionHook({
+    hookName: 'SubagentStart',
+    version: HOOK_VERSIONS.subagentContext,
+    generatedAt,
+    apiKeyPath,
+    apiUrl,
+    preamble: 'Project context for this subagent',
+    timeout: 5000,
+    includeBlockers: false,
+    includeTasks: false,
+    maxGotchas: 5,
+    maxDecisions: 3,
+  });
+}
 
-# Find project config
-find_project_id() {
-  local dir="$PWD"
-  for i in {1..10}; do
-    if [ -f "$dir/.everstate.json" ]; then
-      grep -o '"projectId"[[:space:]]*:[[:space:]]*"[^"]*"' "$dir/.everstate.json" | cut -d'"' -f4
-      return
-    fi
-    dir=$(dirname "$dir")
-    [ "$dir" = "/" ] && break
-  done
+/**
+ * Shared template for hooks that inject Everstate context via stdout.
+ * Used by both PreCompact and SubagentStart hooks.
+ */
+function getContextInjectionHook(opts: {
+  hookName: string;
+  version: string;
+  generatedAt: string;
+  apiKeyPath: string;
+  apiUrl: string;
+  preamble: string;
+  timeout: number;
+  includeBlockers: boolean;
+  includeTasks: boolean;
+  maxGotchas: number;
+  maxDecisions: number;
+  postAction?: string;
+}): string {
+  return `#!/usr/bin/env node
+/**
+ * Everstate ${opts.hookName} Hook v${opts.version}
+ * VERSION: ${opts.version}
+ * GENERATED: ${opts.generatedAt}
+ *
+ * Prints critical Everstate memory to stdout.
+ * Claude adds hook stdout to the agent's context.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const API_KEY_PATH = '${opts.apiKeyPath}';
+const API_URL = '${opts.apiUrl}';
+
+async function main() {
+  if (!fs.existsSync(API_KEY_PATH)) process.exit(0);
+  const apiKey = fs.readFileSync(API_KEY_PATH, 'utf8').trim();
+
+  let projectId = null;
+  let searchDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  for (let i = 0; i < 10; i++) {
+    for (const cn of ['.everstate.json', '.codekeep.json']) {
+      const cp = path.join(searchDir, cn);
+      if (fs.existsSync(cp)) {
+        try { projectId = JSON.parse(fs.readFileSync(cp, 'utf8')).projectId; } catch {}
+      }
+      if (projectId) break;
+    }
+    if (projectId) break;
+    const parent = path.dirname(searchDir);
+    if (parent === searchDir) break;
+    searchDir = parent;
+  }
+  if (!projectId) process.exit(0);
+
+  try {
+    const response = await fetch(\\\`\\\${API_URL}/api/context/handoff?projectId=\\\${projectId}\\\`, {
+      headers: { 'Authorization': \\\`Bearer \\\${apiKey}\\\` },
+      signal: AbortSignal.timeout(${opts.timeout}),
+    });
+    if (!response.ok) process.exit(0);
+    const ctx = await response.json();
+
+    const lines = ['[Everstate] ${opts.preamble}:', ''];
+
+    if (ctx.activeDirective) {
+      lines.push(\\\`## Current Directive: \\\${ctx.activeDirective.title}\\\`);
+      if (ctx.activeDirective.currentFocus) lines.push(\\\`> \\\${ctx.activeDirective.currentFocus}\\\`);
+      if (ctx.activeDirective.branch) lines.push(\\\`Branch: \\\${ctx.activeDirective.branch}\\\`);
+      lines.push('');
+    }
+
+    if (ctx.gotchas && ctx.gotchas.length > 0) {
+      lines.push('## Gotchas');
+      for (const g of ctx.gotchas.slice(0, ${opts.maxGotchas})) {
+        lines.push(\\\`- \\\${g.title}: \\\${g.description.substring(0, 150)}\\\`);
+      }
+      lines.push('');
+    }
+
+    if (ctx.recentDecisions && ctx.recentDecisions.length > 0) {
+      lines.push('## Decisions');
+      for (const d of ctx.recentDecisions.slice(0, ${opts.maxDecisions})) {
+        lines.push(\\\`- \\\${d.summary}\\\${d.rationale ? ' (' + d.rationale.substring(0, 100) + ')' : ''}\\\`);
+      }
+      lines.push('');
+    }
+${opts.includeTasks ? `
+    if (ctx.tasks) {
+      const inProgress = ctx.tasks.inProgress || [];
+      const pending = ctx.tasks.pending || [];
+      if (inProgress.length > 0 || pending.length > 0) {
+        lines.push('## Tasks');
+        for (const t of inProgress) lines.push(\\\`- [in_progress] \\\${t.title}\\\`);
+        for (const t of pending.slice(0, 5)) lines.push(\\\`- [pending] \\\${t.title}\\\`);
+        lines.push('');
+      }
+    }
+` : ''}${opts.includeBlockers ? `
+    if (ctx.blockers && ctx.blockers.length > 0) {
+      lines.push('## Blockers');
+      for (const b of ctx.blockers) {
+        lines.push(\\\`- \\\${b.title} (\\\${b.severity}): \\\${b.description.substring(0, 100)}\\\`);
+      }
+      lines.push('');
+    }
+` : ''}
+    if (ctx.doNotModify && ctx.doNotModify.length > 0) {
+      lines.push('Do not modify:');
+      for (const f of ctx.doNotModify) lines.push(\\\`- \\\${f.filePath}: \\\${f.reason}\\\`);
+      lines.push('');
+    }
+
+    if (lines.length > 2) console.log(lines.join('\\n'));
+${opts.postAction || ''}
+  } catch {
+    try {
+      const cachePath = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.claude', '.gotcha-cache.json');
+      if (fs.existsSync(cachePath)) {
+        const gotchas = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+        if (Array.isArray(gotchas) && gotchas.length > 0) {
+          console.log('[Everstate] Known gotchas:');
+          for (const g of gotchas.slice(0, ${opts.maxGotchas})) console.log(\\\`- \\\${g.title}: \\\${g.description.substring(0, 150)}\\\`);
+        }
+      }
+    } catch {}
+  }
 }
 
-PROJECT_ID=$(find_project_id)
-if [ -z "$PROJECT_ID" ]; then
-  exit 0
-fi
+main().catch(() => process.exit(0));
+`;
+}
+
+/**
+ * Get the implicit-progress.js hook content (PostToolUse for Edit/Write/Bash)
+ */
+export function getImplicitProgressHook(config?: Partial<HookConfig>): string {
+  const apiKeyPath = config?.apiKeyPath || `${getEverstateDir()}/api-key`;
+  const apiUrl = config?.apiUrl || EVERSTATE_API_URL;
+  const generatedAt = config?.generatedAt || new Date().toISOString();
+
+  return `#!/usr/bin/env node
+/**
+ * Everstate Implicit Progress Hook v${HOOK_VERSIONS.syncTodos}
+ * VERSION: ${HOOK_VERSIONS.syncTodos}
+ * GENERATED: ${generatedAt}
+ *
+ * Automatically logs progress when files are edited or commands run.
+ * Runs as PostToolUse hook for Edit, Write, and Bash tools.
+ */
 
-# Get transcript from environment if available
-TRANSCRIPT="\${CLAUDE_TRANSCRIPT:-}"
+const fs = require('fs');
+const path = require('path');
 
-# Signal pre-compact to API
-curl -s -X POST "$API_URL/api/session/pre-compact" \\
-  -H "Content-Type: application/json" \\
-  -H "Authorization: Bearer $API_KEY" \\
-  -d "{\\"projectId\\": \\"$PROJECT_ID\\", \\"transcript\\": \\"\$TRANSCRIPT\\"}" > /dev/null 2>&1
+const API_KEY_PATH = '${apiKeyPath}';
+const API_URL = '${apiUrl}';
 
-exit 0
+let stdinData = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => stdinData += chunk);
+process.stdin.on('end', () => main());
+
+async function main() {
+  try {
+    if (!fs.existsSync(API_KEY_PATH)) process.exit(0);
+    const apiKey = fs.readFileSync(API_KEY_PATH, 'utf8').trim();
+
+    const hookData = JSON.parse(stdinData || '{}');
+    const toolName = hookData.tool_name;
+    const toolInput = hookData.tool_input || {};
+
+    let activity = null;
+    if (toolName === 'Edit' || toolName === 'Write') {
+      const filePath = toolInput.file_path || toolInput.filePath || '';
+      if (filePath) activity = { tool: toolName.toLowerCase(), file: path.basename(filePath), path: filePath };
+    } else if (toolName === 'Bash') {
+      const cmd = toolInput.command || '';
+      if (cmd && !cmd.startsWith('git status') && !cmd.startsWith('ls '))
+        activity = { tool: 'bash', command: cmd.substring(0, 100) };
+    }
+
+    if (!activity) process.exit(0);
+
+    // Find project
+    let projectId = null;
+    let searchDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    for (let i = 0; i < 10; i++) {
+      for (const cn of ['.everstate.json', '.codekeep.json']) {
+        const cp = path.join(searchDir, cn);
+        if (fs.existsSync(cp)) {
+          try { projectId = JSON.parse(fs.readFileSync(cp, 'utf8')).projectId; } catch {}
+        }
+        if (projectId) break;
+      }
+      if (projectId) break;
+      const parent = path.dirname(searchDir);
+      if (parent === searchDir) break;
+      searchDir = parent;
+    }
+    if (!projectId) process.exit(0);
+
+    // Debounce: 1 per file per 60s
+    const df = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.claude', '.progress-debounce.json');
+    let db = {};
+    try { if (fs.existsSync(df)) db = JSON.parse(fs.readFileSync(df, 'utf8')); } catch {}
+    const key = activity.file || activity.command || 'x';
+    const now = Date.now();
+    if (db[key] && (now - db[key]) < 60000) process.exit(0);
+    db[key] = now;
+    for (const [k, v] of Object.entries(db)) { if ((now - v) > 300000) delete db[k]; }
+    try { fs.mkdirSync(path.dirname(df), { recursive: true }); fs.writeFileSync(df, JSON.stringify(db)); } catch {}
+
+    await fetch(\`\${API_URL}/api/session/implicit-progress\`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': \`Bearer \${apiKey}\` },
+      body: JSON.stringify({ projectId, activity }),
+    }).catch(() => {});
+  } catch {}
+  process.exit(0);
+}
+`;
+}
+
+/**
+ * Get the gotcha-check.js hook content (PreToolUse for Edit/Write)
+ */
+export function getGotchaCheckHook(config?: Partial<HookConfig>): string {
+  const generatedAt = config?.generatedAt || new Date().toISOString();
+
+  return `#!/usr/bin/env node
+/**
+ * Everstate Gotcha Check Hook v${HOOK_VERSIONS.syncTodos}
+ * VERSION: ${HOOK_VERSIONS.syncTodos}
+ * GENERATED: ${generatedAt}
+ *
+ * Surfaces relevant gotchas before file edits.
+ * Runs as PreToolUse hook for Edit and Write tools.
+ *
+ * Claude Code passes hook data via STDIN as JSON:
+ * { "tool_name": "Edit", "tool_input": { "file_path": "..." }, ... }
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let stdinData = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => stdinData += chunk);
+process.stdin.on('end', () => main());
+
+function main() {
+  try {
+    const hookData = JSON.parse(stdinData || '{}');
+    const filePath = hookData.tool_input?.file_path || hookData.tool_input?.filePath || '';
+    if (!filePath) {
+      process.exit(0);
+    }
+
+    // Read gotcha cache
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    const cachePath = path.join(projectDir, '.claude', '.gotcha-cache.json');
+    if (!fs.existsSync(cachePath)) {
+      process.exit(0);
+    }
+
+    const gotchas = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+    if (!Array.isArray(gotchas) || gotchas.length === 0) {
+      process.exit(0);
+    }
+
+    // Match gotchas against file path
+    const fileLC = filePath.toLowerCase();
+    const fileName = path.basename(filePath).toLowerCase();
+    const matched = [];
+
+    for (const gotcha of gotchas) {
+      if (!gotcha.keywords || !Array.isArray(gotcha.keywords)) continue;
+      for (const keyword of gotcha.keywords) {
+        if (fileLC.includes(keyword) || fileName.includes(keyword)) {
+          matched.push(gotcha);
+          break;
+        }
+      }
+    }
+
+    if (matched.length > 0) {
+      const sevIcon = { critical: '!!!', warning: '>>', info: '>' };
+      console.log('');
+      console.log('[Everstate] Gotcha warning for ' + path.basename(filePath) + ':');
+      for (const g of matched.slice(0, 3)) {
+        console.log((sevIcon[g.severity] || '>>') + ' ' + g.title + ': ' + g.description.substring(0, 150));
+      }
+      console.log('');
+    }
+  } catch {
+    // Silent failure - don't block tool execution
+  }
+  process.exit(0);
+}
 `;
 }
 
@@ -252,4 +606,7 @@ export const hookTemplates = {
   sessionStart: getSessionStartHook,
   sessionEnd: getSessionEndHook,
   preCompact: getPreCompactHook,
+  subagentContext: getSubagentContextHook,
+  gotchaCheck: getGotchaCheckHook,
+  implicitProgress: getImplicitProgressHook,
 };

package/src/setup/types.ts

@@ -177,7 +177,9 @@ export function c(color: keyof Colors, text: string): string {
 export const HOOK_VERSIONS = {
   sessionStart: '1.1.0',
   sessionEnd: '1.1.0',
-  syncTodos: '5.1.0',  // Fixed: read from stdin instead of TOOL_INPUT env var
+  syncTodos: '6.0.0',  // Two-way sync: dashboard changes reported back to Claude via stdout
+  preCompact: '2.0.0', // Re-injects critical context (gotchas, decisions, tasks) before compaction
+  subagentContext: '1.0.0', // Injects project context when subagents spawn
 };
 
 export const EVERSTATE_API_URL = 'https://www.everstate.ai';