claude-mem/hook-templates/post-tool-use.js

#!/usr/bin/env node

/**
 * Post Tool Use Hook - Streaming SDK Version
 *
 * Feeds tool responses to the streaming SDK session for real-time processing.
 * SDK decides what to store and calls bash commands directly.
 */

import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';
import { query } from '@anthropic-ai/claude-agent-sdk';
import { renderToolMessage, HOOK_CONFIG } from './shared/hook-prompt-renderer.js';
import { getProjectName } from './shared/path-resolver.js';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const SESSION_DIR = path.join(process.env.HOME || '', '.claude-mem', 'sessions');
const HOOKS_LOG = path.join(process.env.HOME || '', '.claude-mem', 'logs', 'hooks.log');

function debugLog(message, data = {}) {
  if (process.env.CLAUDE_MEM_DEBUG === 'true') {
    const timestamp = new Date().toISOString();
    const logLine = `[${timestamp}] HOOK DEBUG: ${message} ${JSON.stringify(data)}\n`;
    try {
      fs.appendFileSync(HOOKS_LOG, logLine);
      process.stderr.write(logLine);
    } catch (error) {
      // Silent fail on log errors
    }
  }
}

// Removed: buildStreamingToolMessage function
// Now using centralized config from hook-prompt-renderer.js

// =============================================================================
// MAIN
// =============================================================================

let input = '';
process.stdin.setEncoding('utf8');
process.stdin.on('data', (chunk) => { input += chunk; });

process.stdin.on('end', async () => {
  let payload;
  try {
    payload = input ? JSON.parse(input) : {};
  } catch (error) {
    debugLog('PostToolUse: JSON parse error', { error: error.message });
    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
    process.exit(0);
  }

  const { tool_name, tool_response, prompt, cwd, timestamp } = payload;
  const project = cwd ? getProjectName(cwd) : 'unknown';

  // Return immediately - process async in background (don't block next tool)
  console.log(JSON.stringify({ async: true, asyncTimeout: 180000 }));

  try {
    // Load SDK session info
    const sessionFile = path.join(SESSION_DIR, `${project}_streaming.json`);
    if (!fs.existsSync(sessionFile)) {
      debugLog('PostToolUse: No streaming session found', { project });
      process.exit(0);
    }

    const sessionData = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
    const sdkSessionId = sessionData.sdkSessionId;

    // Convert tool response to string
    const toolResponseStr = typeof tool_response === 'string'
      ? tool_response
      : JSON.stringify(tool_response);

    // Build message for SDK using centralized config
    const message = renderToolMessage({
      toolName: tool_name,
      toolResponse: toolResponseStr,
      userPrompt: prompt || '',
      timestamp: timestamp || new Date().toISOString()
    });

    // Send to SDK and wait for processing to complete using centralized config
    const response = query({
      prompt: message,
      options: {
        model: HOOK_CONFIG.sdk.model,
        resume: sdkSessionId,
        allowedTools: HOOK_CONFIG.sdk.allowedTools,
        maxTokens: HOOK_CONFIG.sdk.maxTokensTool,
        cwd  // Must match where transcript was created
      }
    });

    // Consume the stream to let SDK fully process
    for await (const msg of response) {
      debugLog('PostToolUse: SDK message', { type: msg.type, subtype: msg.subtype });

      // SDK messages are structured differently than we expected
      // - type: 'assistant' contains the assistant's response with content blocks
      // - Content blocks can be text or tool_use
      // - type: 'user' contains tool results
      // - type: 'result' is the final summary

      if (msg.type === 'assistant' && msg.message?.content) {
        for (const block of msg.message.content) {
          if (block.type === 'text') {
            debugLog('PostToolUse: SDK text', { text: block.text?.slice(0, 200) });
          } else if (block.type === 'tool_use') {
            debugLog('PostToolUse: SDK tool_use', {
              tool: block.name,
              input: JSON.stringify(block.input).slice(0, 200)
            });
          }
        }
      } else if (msg.type === 'user' && msg.message?.content) {
        for (const block of msg.message.content) {
          if (block.type === 'tool_result') {
            debugLog('PostToolUse: SDK tool_result', {
              tool_use_id: block.tool_use_id,
              content: typeof block.content === 'string' ? block.content.slice(0, 300) : JSON.stringify(block.content).slice(0, 300)
            });
          }
        }
      } else if (msg.type === 'result') {
        debugLog('PostToolUse: SDK result', {
          subtype: msg.subtype,
          is_error: msg.is_error
        });
      }
    }

    debugLog('PostToolUse: SDK finished processing', { tool_name, sdkSessionId });
  } catch (error) {
    debugLog('PostToolUse: Error sending to SDK', { error: error.message });
  }

  // Exit cleanly after async processing completes
  process.exit(0);
});