shieldcortex 2.0.0

package/scripts/session-start-hook.mjs

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * Session Start Hook for ShieldCortex - Auto-Recall Context
+ *
+ * This script runs when Claude Code starts a new session and:
+ * 1. Detects the current project from the working directory
+ * 2. Retrieves relevant context from memory
+ * 3. Outputs it so Claude has immediate access to project knowledge
+ *
+ * The goal: Claude always starts with relevant project context.
+ */
+
+import Database from 'better-sqlite3';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Database paths (with legacy fallback)
+const NEW_DB_DIR = join(homedir(), '.shieldcortex');
+const LEGACY_DB_DIR = join(homedir(), '.claude-cortex');
+
+// Auto-detect: use new path if it exists, or if legacy doesn't exist (new install)
+function getDbPath() {
+  const newPath = join(NEW_DB_DIR, 'memories.db');
+  const legacyPath = join(LEGACY_DB_DIR, 'memories.db');
+  if (existsSync(newPath) || !existsSync(legacyPath)) {
+    return { dir: NEW_DB_DIR, path: newPath };
+  }
+  return { dir: LEGACY_DB_DIR, path: legacyPath };
+}
+
+const { dir: DB_DIR, path: DB_PATH } = getDbPath();
+
+// Configuration
+const MAX_CONTEXT_MEMORIES = 15;
+const MIN_SALIENCE_THRESHOLD = 0.3;
+
+// ==================== PROJECT DETECTION (Mirrors src/context/project-context.ts) ====================
+
+const SKIP_DIRECTORIES = [
+  'src', 'lib', 'dist', 'build', 'out',
+  'node_modules', '.git', '.next', '.cache',
+  'test', 'tests', '__tests__', 'spec',
+  'bin', 'scripts', 'config', 'public', 'static',
+];
+
+function extractProjectFromPath(path) {
+  if (!path) return null;
+
+  const segments = path.split(/[/\\]/).filter(Boolean);
+  if (segments.length === 0) return null;
+
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i];
+    if (!SKIP_DIRECTORIES.includes(segment.toLowerCase())) {
+      if (segment.startsWith('.')) continue;
+      return segment;
+    }
+  }
+
+  return null;
+}
+
+// ==================== CONTEXT RETRIEVAL ====================
+
+function getProjectContext(db, project) {
+  const memories = [];
+
+  // Get high-priority memories for this project
+  const highPriority = db.prepare(`
+    SELECT id, title, content, category, type, salience, tags, created_at
+    FROM memories
+    WHERE (project = ? OR project IS NULL)
+      AND salience >= ?
+      AND type IN ('long_term', 'episodic')
+    ORDER BY salience DESC, last_accessed DESC
+    LIMIT ?
+  `).all(project, MIN_SALIENCE_THRESHOLD, MAX_CONTEXT_MEMORIES);
+
+  memories.push(...highPriority);
+
+  // If we don't have enough, get recent memories too
+  if (memories.length < 5) {
+    const excludeIds = memories.map(m => m.id);
+    const placeholders = excludeIds.length > 0 ? excludeIds.map(() => '?').join(',') : '0';
+    const recent = db.prepare(`
+      SELECT id, title, content, category, type, salience, tags, created_at
+      FROM memories
+      WHERE (project = ? OR project IS NULL)
+        AND id NOT IN (${placeholders})
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).all(project, ...excludeIds, 5 - memories.length);
+
+    memories.push(...recent);
+  }
+
+  return memories;
+}
+
+function formatContext(memories, project) {
+  if (memories.length === 0) {
+    return null;
+  }
+
+  const lines = [
+    `# Project Context: ${project}`,
+    '',
+  ];
+
+  // Group by category
+  const byCategory = {};
+  for (const mem of memories) {
+    const cat = mem.category || 'note';
+    if (!byCategory[cat]) byCategory[cat] = [];
+    byCategory[cat].push(mem);
+  }
+
+  // Priority order for categories
+  const categoryOrder = ['architecture', 'pattern', 'preference', 'error', 'context', 'learning', 'note', 'todo'];
+
+  for (const cat of categoryOrder) {
+    if (!byCategory[cat] || byCategory[cat].length === 0) continue;
+
+    const categoryTitle = cat.charAt(0).toUpperCase() + cat.slice(1);
+    lines.push(`## ${categoryTitle}`);
+
+    for (const mem of byCategory[cat]) {
+      const salience = Math.round(mem.salience * 100);
+      lines.push(`- **${mem.title}** (${salience}% salience)`);
+      // Truncate long content
+      const content = mem.content.length > 200
+        ? mem.content.slice(0, 200) + '...'
+        : mem.content;
+      lines.push(`  ${content}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+// ==================== MAIN HOOK LOGIC ====================
+
+let input = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('readable', () => {
+  let chunk;
+  while ((chunk = process.stdin.read()) !== null) {
+    input += chunk;
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    const hookData = JSON.parse(input || '{}');
+    const project = extractProjectFromPath(hookData.cwd || process.cwd());
+
+    if (!project) {
+      // No project detected, skip context retrieval
+      process.exit(0);
+    }
+
+    // Check if database exists
+    if (!existsSync(DB_PATH)) {
+      console.error('[session-start] Memory database not found, skipping context retrieval');
+      process.exit(0);
+    }
+
+    // Connect to database (read-only to avoid contention)
+    // timeout: 5000ms to handle busy database during concurrent access
+    const db = new Database(DB_PATH, { readonly: true, timeout: 5000 });
+
+    // Get project context
+    const memories = getProjectContext(db, project);
+    const context = formatContext(memories, project);
+
+    db.close();
+
+    // Proactive memory instructions
+    const proactiveInstructions = `
+## IMPORTANT: Proactive Memory Use
+
+You have access to a persistent memory system. Use it proactively:
+
+**ALWAYS use \`remember\` immediately when:**
+- Making architecture/design decisions
+- Fixing bugs (capture the root cause and solution)
+- Learning something new about the codebase
+- User states a preference
+- Completing significant features
+
+**Don't wait** - call \`remember\` right after the event, not at the end of the session.
+`;
+
+    if (context) {
+      // Output context to stdout - this will be shown to Claude
+      console.log(`
+🧠 SHIELDCORTEX - Project "${project}"
+
+${context}
+${proactiveInstructions}
+`);
+      console.error(`[shieldcortex] Session start: loaded ${memories.length} memories for "${project}"`);
+    } else {
+      console.log(`
+🧠 SHIELDCORTEX - New project "${project}"
+
+No stored memories yet for this project.
+${proactiveInstructions}
+`);
+      console.error(`[shieldcortex] Session start: no memories found for "${project}"`);
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error(`[session-start] Error: ${error.message}`);
+    process.exit(0); // Don't block session start on errors
+  }
+});

package/scripts/start-dashboard.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+# ShieldCortex Dashboard Startup Script
+# Starts both the API server and Next.js dashboard
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+LOG_DIR="$HOME/.shieldcortex/logs"
+
+# Create log directory
+mkdir -p "$LOG_DIR"
+
+# Kill any existing instances
+pkill -f "node.*visualization-server" 2>/dev/null
+pkill -f "next-server.*3030" 2>/dev/null
+
+# Wait for processes to stop
+sleep 1
+
+# Start API server (port 3001)
+cd "$PROJECT_DIR"
+nohup npm run dev:api > "$LOG_DIR/api-server.log" 2>&1 &
+API_PID=$!
+echo "API server started (PID: $API_PID)"
+
+# Wait for API to be ready
+sleep 2
+
+# Start Next.js dashboard (port 3030)
+cd "$PROJECT_DIR/dashboard"
+nohup npm run dev > "$LOG_DIR/dashboard.log" 2>&1 &
+DASHBOARD_PID=$!
+echo "Dashboard started (PID: $DASHBOARD_PID)"
+
+# Save PIDs for later shutdown
+echo "$API_PID" > "$LOG_DIR/api-server.pid"
+echo "$DASHBOARD_PID" > "$LOG_DIR/dashboard.pid"
+
+echo "ShieldCortex Dashboard running:"
+echo "  - API: http://localhost:3001"
+echo "  - Dashboard: http://localhost:3030"
+echo "  - Logs: $LOG_DIR"

package/scripts/stop-dashboard.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# Stop ShieldCortex Dashboard
+
+LOG_DIR="$HOME/.shieldcortex/logs"
+
+# Kill by PID files if they exist
+if [ -f "$LOG_DIR/api-server.pid" ]; then
+  kill $(cat "$LOG_DIR/api-server.pid") 2>/dev/null
+  rm "$LOG_DIR/api-server.pid"
+fi
+
+if [ -f "$LOG_DIR/dashboard.pid" ]; then
+  kill $(cat "$LOG_DIR/dashboard.pid") 2>/dev/null
+  rm "$LOG_DIR/dashboard.pid"
+fi
+
+# Also kill by process name as fallback
+pkill -f "node.*visualization-server" 2>/dev/null
+pkill -f "next-server.*3030" 2>/dev/null
+
+echo "ShieldCortex Dashboard stopped"

package/scripts/stop-hook.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+/**
+ * ShieldCortex — Stop Hook
+ *
+ * Fires after each Claude response. Checks the last assistant message for
+ * high-salience content (decisions, fixes, learnings) that should be saved
+ * to memory via the `remember` tool.
+ *
+ * Loop prevention: If stop_hook_active is true, exits 0 immediately
+ * (programmatic check, not LLM-dependent).
+ *
+ * Exit codes:
+ *   0 = allow Claude to stop
+ *   2 = block stop (stderr tells Claude to use `remember`)
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+
+// ==================== SALIENCE DETECTION ====================
+
+const DECISION_KEYWORDS = [
+  'decided', 'decision', 'chose', 'chosen', 'selected', 'going with',
+  'will use', 'opted for', 'settled on', 'agreed'
+];
+
+const ERROR_KEYWORDS = [
+  'fixed by', 'the fix was', 'root cause', 'the bug was', 'the solution was',
+  'resolved by', 'the issue was', 'workaround'
+];
+
+const LEARNING_KEYWORDS = [
+  'learned that', 'discovered that', 'realized that', 'found out',
+  'turns out', 'TIL', 'figured out'
+];
+
+const ARCHITECTURE_KEYWORDS = [
+  'architecture uses', 'design decision', 'implemented', 'refactored to',
+  'migrated from', 'created a new', 'built a'
+];
+
+const PREFERENCE_KEYWORDS = [
+  'always use', 'never use', 'prefer to', 'convention is',
+  'standard is', 'rule is'
+];
+
+const IMPORTANT_MARKERS = [
+  'important:', 'remember:', 'key point', 'crucial:', 'note:'
+];
+
+function detectKeywords(text, keywords) {
+  const lower = text.toLowerCase();
+  return keywords.some(kw => lower.includes(kw.toLowerCase()));
+}
+
+/**
+ * Check if text contains high-salience content worth remembering.
+ * Returns a description string if yes, null if no.
+ */
+function detectNotableContent(text) {
+  const lower = text.toLowerCase();
+
+  if (detectKeywords(lower, DECISION_KEYWORDS)) {
+    return 'A decision was made in the last response';
+  }
+  if (detectKeywords(lower, ERROR_KEYWORDS)) {
+    return 'A bug fix or error resolution was described';
+  }
+  if (detectKeywords(lower, LEARNING_KEYWORDS)) {
+    return 'Something new was learned or discovered';
+  }
+  if (detectKeywords(lower, ARCHITECTURE_KEYWORDS)) {
+    return 'An architecture or design change was made';
+  }
+  if (detectKeywords(lower, PREFERENCE_KEYWORDS)) {
+    return 'A preference or convention was stated';
+  }
+  if (detectKeywords(lower, IMPORTANT_MARKERS)) {
+    return 'Something was marked as important';
+  }
+
+  return null;
+}
+
+/**
+ * Read the last assistant message from the transcript JSONL.
+ */
+function getLastAssistantMessage(transcriptPath) {
+  if (!transcriptPath) return '';
+
+  const resolved = transcriptPath.replace(/^~/, homedir());
+  if (!existsSync(resolved)) return '';
+
+  try {
+    const content = readFileSync(resolved, 'utf-8');
+    const lines = content.trim().split('\n');
+
+    // Read from the end to find the last assistant message
+    for (let i = lines.length - 1; i >= Math.max(0, lines.length - 20); i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        const role = entry.type || entry.message?.role;
+        if (role === 'assistant' && entry.message?.content) {
+          const msgContent = entry.message.content;
+          return Array.isArray(msgContent)
+            ? msgContent.filter(c => c.type === 'text').map(c => c.text).join('\n')
+            : msgContent;
+        }
+      } catch {
+        // Skip invalid lines
+      }
+    }
+    return '';
+  } catch {
+    return '';
+  }
+}
+
+// ==================== MAIN ====================
+
+async function main() {
+  let hookData;
+  try {
+    const stdin = readFileSync(0, 'utf-8');
+    hookData = JSON.parse(stdin);
+  } catch {
+    // No stdin or invalid JSON — allow stop
+    process.exit(0);
+  }
+
+  // PROGRAMMATIC LOOP PREVENTION
+  // If Claude is already continuing from a stop hook, always allow stop.
+  if (hookData.stop_hook_active === true) {
+    process.exit(0);
+  }
+
+  // Read the last assistant message
+  const lastMessage = getLastAssistantMessage(hookData.transcript_path);
+  if (!lastMessage || lastMessage.length < 50) {
+    // Too short to contain anything notable
+    process.exit(0);
+  }
+
+  // Check for notable content
+  const description = detectNotableContent(lastMessage);
+  if (description) {
+    // Block stop — tell Claude to use remember
+    process.stderr.write(
+      `Use the remember tool to save what just happened: ${description}. ` +
+      `Then continue with your response.`
+    );
+    process.exit(2);
+  }
+
+  // Nothing notable — allow stop
+  process.exit(0);
+}
+
+main().catch(() => {
+  // Never crash Claude Code
+  process.exit(0);
+});