clearctx 3.0.0

package/bin/continuity-hook.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * continuity-hook.js — Entry point for Claude Code lifecycle hooks.
+ *
+ * Claude Code hooks call this script with the event type as the first argument.
+ * Hook JSON is passed on stdin.
+ *
+ * Usage (called by Claude Code, not by users):
+ *   node continuity-hook.js SessionStart   < {hook JSON on stdin}
+ *   node continuity-hook.js Stop           < {hook JSON on stdin}
+ *   node continuity-hook.js PreCompact     < {hook JSON on stdin}
+ *   node continuity-hook.js SessionEnd     < {hook JSON on stdin}
+ *
+ * The script reads all stdin, parses it as JSON, extracts working_directory
+ * and session_id, then calls the appropriate handler from continuity-hooks.js.
+ *
+ * On SessionStart and PreCompact, the handler can return a JSON object with
+ * { additionalContext: "string" } which gets injected into Claude's conversation.
+ *
+ * On Stop and SessionEnd, there is no return value needed (async hooks).
+ *
+ * CRITICAL: This script must NEVER crash or throw unhandled errors.
+ * A crashing hook blocks Claude Code. Wrap everything in try/catch.
+ * On any error, log to stderr and exit 0 (success) so Claude Code continues.
+ */
+
+// Top-level try/catch to ensure we NEVER crash
+try {
+  // Get the event type from the first CLI argument
+  const eventType = process.argv[2];
+
+  // If no event type provided, exit silently
+  if (!eventType) {
+    process.exit(0);
+  }
+
+  // Read all of stdin (it's a single JSON blob, not streaming)
+  let stdinData = '';
+  const chunks = [];
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => {
+    chunks.push(chunk);
+  });
+
+  process.stdin.on('end', () => {
+    try {
+      stdinData = chunks.join('');
+
+      // Parse the JSON input from Claude Code
+      let input = {};
+      if (stdinData.trim()) {
+        input = JSON.parse(stdinData);
+      }
+
+      // For Stop events, check the stop_hook_active flag to prevent infinite loops
+      if (eventType === 'Stop' && input.stop_hook_active) {
+        process.exit(0);
+      }
+
+      // Load the handler module
+      const handlers = require('../src/continuity-hooks');
+
+      // Map event types to handler functions
+      const handlerMap = {
+        'SessionStart': handlers.handleSessionStart,
+        'Stop': handlers.handleStop,
+        'PreCompact': handlers.handlePreCompact,
+        'SessionEnd': handlers.handleSessionEnd
+      };
+
+      // Find the handler for this event type
+      const handler = handlerMap[eventType];
+      if (!handler) {
+        // Unknown event type — exit silently
+        process.exit(0);
+      }
+
+      // Call the handler with the parsed input
+      const result = handler(input);
+
+      // If the handler returned additionalContext, write it to stdout
+      // so Claude Code can inject it into the conversation
+      if (result && result.additionalContext) {
+        const output = JSON.stringify({
+          hookSpecificOutput: {
+            additionalContext: result.additionalContext
+          }
+        });
+        process.stdout.write(output);
+      }
+
+      process.exit(0);
+
+    } catch (err) {
+      // Log the error to stderr so it shows in debug logs but doesn't crash Claude Code
+      console.error('[continuity-hook] Error:', err.message);
+      process.exit(0); // Always exit 0 — never block Claude Code
+    }
+  });
+
+  // Handle stdin errors gracefully
+  process.stdin.on('error', () => {
+    process.exit(0);
+  });
+
+  // If stdin is already closed (piped empty), trigger 'end' manually
+  if (process.stdin.isTTY) {
+    process.stdin.emit('end');
+  }
+
+} catch (err) {
+  // Outermost catch — if even requiring modules fails, exit cleanly
+  console.error('[continuity-hook] Fatal:', err.message);
+  process.exit(0);
+}

package/bin/mcp.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+/**
+ * clearctx MCP Server entry point.
+ *
+ * This starts the MCP (Model Context Protocol) server that exposes
+ * multi-session tools to Claude Code as native tools.
+ *
+ * Claude Code connects to this server via stdio. Once connected,
+ * tools like spawn_session, send_message, delegate_task appear
+ * in Claude's tool list — just like Read, Edit, Grep, etc.
+ *
+ * Usage (in Claude Code MCP config):
+ *   {
+ *     "mcpServers": {
+ *       "multi-session": {
+ *         "command": "ctx-mcp"
+ *       }
+ *     }
+ *   }
+ *
+ * Or run directly:
+ *   node bin/mcp.js
+ */
+
+const { startServer } = require('../src/mcp-server');
+startServer();