@stackmemoryai/stackmemory 0.5.58 → 0.5.59

package/dist/src/utils/process-cleanup.js

@@ -0,0 +1,136 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { logger } from "../core/monitoring/logger.js";
+const STACKMEMORY_PROCESS_PATTERNS = [
+  "stackmemory",
+  "ralph orchestrate",
+  "ralph swarm",
+  "ralph loop",
+  "hooks start"
+];
+function getStackmemoryProcesses() {
+  const processes = [];
+  try {
+    const psOutput = execSync(
+      "ps -eo pid,lstart,command 2>/dev/null || ps -eo pid,start,args 2>/dev/null",
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    const lines = psOutput.trim().split("\n").slice(1);
+    for (const line of lines) {
+      const isStackmemory = STACKMEMORY_PROCESS_PATTERNS.some(
+        (pattern) => line.toLowerCase().includes(pattern.toLowerCase())
+      );
+      if (!isStackmemory) continue;
+      const match = line.match(
+        /^\s*(\d+)\s+(\w+\s+\w+\s+\d+\s+[\d:]+\s+\d+)\s+(.+)$/
+      );
+      if (match) {
+        const pid = parseInt(match[1], 10);
+        const startTimeStr = match[2];
+        const command = match[3];
+        if (pid === process.pid) continue;
+        const startTime = new Date(startTimeStr);
+        const ageMs = Date.now() - startTime.getTime();
+        const ageHours = ageMs / (1e3 * 60 * 60);
+        processes.push({
+          pid,
+          command: command.slice(0, 100),
+          // Truncate long commands
+          startTime,
+          ageHours
+        });
+      }
+    }
+  } catch (error) {
+    logger.warn("Failed to get process list:", error);
+  }
+  return processes;
+}
+function hasRecentLogActivity(proc, maxAgeHours) {
+  const logDir = path.join(os.homedir(), ".stackmemory", "logs");
+  if (!fs.existsSync(logDir)) return false;
+  try {
+    const logFiles = fs.readdirSync(logDir).filter((f) => f.endsWith(".log"));
+    for (const logFile of logFiles) {
+      const logPath = path.join(logDir, logFile);
+      const stats = fs.statSync(logPath);
+      const logAgeHours = (Date.now() - stats.mtimeMs) / (1e3 * 60 * 60);
+      if (logAgeHours < maxAgeHours) {
+        try {
+          const content = fs.readFileSync(logPath, "utf-8").slice(-1e4);
+          if (content.includes(`pid:${proc.pid}`) || content.includes(`PID ${proc.pid}`)) {
+            proc.logFile = logPath;
+            proc.lastLogActivity = stats.mtime;
+            return true;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch (error) {
+    logger.warn("Failed to check log activity:", error);
+  }
+  return false;
+}
+function findStaleProcesses(maxAgeHours = 24) {
+  const allProcesses = getStackmemoryProcesses();
+  return allProcesses.filter((proc) => {
+    if (proc.ageHours < maxAgeHours) return false;
+    if (hasRecentLogActivity(proc, maxAgeHours)) return false;
+    return true;
+  });
+}
+function killStaleProcesses(processes, dryRun = false) {
+  const result = {
+    found: processes,
+    killed: [],
+    errors: []
+  };
+  for (const proc of processes) {
+    if (dryRun) {
+      logger.info(`[DRY RUN] Would kill PID ${proc.pid}: ${proc.command}`);
+      continue;
+    }
+    try {
+      process.kill(proc.pid, "SIGTERM");
+      result.killed.push(proc.pid);
+      logger.info(`Killed stale process ${proc.pid}: ${proc.command}`);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ESRCH") {
+        result.killed.push(proc.pid);
+      } else {
+        result.errors.push({
+          pid: proc.pid,
+          error: err.message || "Unknown error"
+        });
+        logger.warn(`Failed to kill PID ${proc.pid}:`, err.message);
+      }
+    }
+  }
+  return result;
+}
+function cleanupStaleProcesses(options = {}) {
+  const { maxAgeHours = 24, dryRun = false } = options;
+  logger.info(`Looking for stale processes older than ${maxAgeHours}h...`);
+  const staleProcesses = findStaleProcesses(maxAgeHours);
+  if (staleProcesses.length === 0) {
+    logger.info("No stale processes found");
+    return { found: [], killed: [], errors: [] };
+  }
+  logger.info(`Found ${staleProcesses.length} stale process(es)`);
+  return killStaleProcesses(staleProcesses, dryRun);
+}
+export {
+  cleanupStaleProcesses,
+  findStaleProcesses,
+  getStackmemoryProcesses,
+  killStaleProcesses
+};
+//# sourceMappingURL=process-cleanup.js.map

package/dist/src/utils/process-cleanup.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/process-cleanup.ts"],
+  "sourcesContent": ["/**\n * Process Cleanup Utility\n * Automatically cleans up stale stackmemory processes older than 24h\n * with no recent log activity.\n */\n\nimport { execSync } from 'child_process';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as os from 'os';\nimport { logger } from '../core/monitoring/logger.js';\n\nexport interface StaleProcess {\n  pid: number;\n  command: string;\n  startTime: Date;\n  ageHours: number;\n  logFile?: string;\n  lastLogActivity?: Date;\n}\n\nexport interface CleanupResult {\n  found: StaleProcess[];\n  killed: number[];\n  errors: Array<{ pid: number; error: string }>;\n}\n\nconst STACKMEMORY_PROCESS_PATTERNS = [\n  'stackmemory',\n  'ralph orchestrate',\n  'ralph swarm',\n  'ralph loop',\n  'hooks start',\n];\n\n/**\n * Get all running stackmemory-related processes\n */\nexport function getStackmemoryProcesses(): StaleProcess[] {\n  const processes: StaleProcess[] = [];\n\n  try {\n    // Get process list with start time (macOS/Linux compatible)\n    const psOutput = execSync(\n      'ps -eo pid,lstart,command 2>/dev/null || ps -eo pid,start,args 2>/dev/null',\n      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }\n    );\n\n    const lines = psOutput.trim().split('\\n').slice(1); // Skip header\n\n    for (const line of lines) {\n      // Check if it's a stackmemory process\n      const isStackmemory = STACKMEMORY_PROCESS_PATTERNS.some((pattern) =>\n        line.toLowerCase().includes(pattern.toLowerCase())\n      );\n\n      if (!isStackmemory) continue;\n\n      // Parse the line - format varies by OS\n      // macOS: PID \"Day Mon DD HH:MM:SS YYYY\" COMMAND\n      const match = line.match(\n        /^\\s*(\\d+)\\s+(\\w+\\s+\\w+\\s+\\d+\\s+[\\d:]+\\s+\\d+)\\s+(.+)$/\n      );\n\n      if (match) {\n        const pid = parseInt(match[1], 10);\n        const startTimeStr = match[2];\n        const command = match[3];\n\n        // Skip current process\n        if (pid === process.pid) continue;\n\n        // Parse start time\n        const startTime = new Date(startTimeStr);\n        const ageMs = Date.now() - startTime.getTime();\n        const ageHours = ageMs / (1000 * 60 * 60);\n\n        processes.push({\n          pid,\n          command: command.slice(0, 100), // Truncate long commands\n          startTime,\n          ageHours,\n        });\n      }\n    }\n  } catch (error) {\n    logger.warn('Failed to get process list:', error);\n  }\n\n  return processes;\n}\n\n/**\n * Check if a process has recent log activity\n */\nfunction hasRecentLogActivity(\n  proc: StaleProcess,\n  maxAgeHours: number\n): boolean {\n  const logDir = path.join(os.homedir(), '.stackmemory', 'logs');\n\n  if (!fs.existsSync(logDir)) return false;\n\n  try {\n    // Look for log files that might be related to this process\n    const logFiles = fs.readdirSync(logDir).filter((f) => f.endsWith('.log'));\n\n    for (const logFile of logFiles) {\n      const logPath = path.join(logDir, logFile);\n      const stats = fs.statSync(logPath);\n      const logAgeHours = (Date.now() - stats.mtimeMs) / (1000 * 60 * 60);\n\n      if (logAgeHours < maxAgeHours) {\n        // Check if log contains this PID\n        try {\n          const content = fs.readFileSync(logPath, 'utf-8').slice(-10000); // Last 10KB\n          if (\n            content.includes(`pid:${proc.pid}`) ||\n            content.includes(`PID ${proc.pid}`)\n          ) {\n            proc.logFile = logPath;\n            proc.lastLogActivity = stats.mtime;\n            return true;\n          }\n        } catch {\n          // Ignore read errors\n        }\n      }\n    }\n  } catch (error) {\n    logger.warn('Failed to check log activity:', error);\n  }\n\n  return false;\n}\n\n/**\n * Find stale processes older than specified hours with no recent log activity\n */\nexport function findStaleProcesses(maxAgeHours: number = 24): StaleProcess[] {\n  const allProcesses = getStackmemoryProcesses();\n\n  return allProcesses.filter((proc) => {\n    // Must be older than threshold\n    if (proc.ageHours < maxAgeHours) return false;\n\n    // Check for recent log activity\n    if (hasRecentLogActivity(proc, maxAgeHours)) return false;\n\n    return true;\n  });\n}\n\n/**\n * Kill stale processes\n */\nexport function killStaleProcesses(\n  processes: StaleProcess[],\n  dryRun: boolean = false\n): CleanupResult {\n  const result: CleanupResult = {\n    found: processes,\n    killed: [],\n    errors: [],\n  };\n\n  for (const proc of processes) {\n    if (dryRun) {\n      logger.info(`[DRY RUN] Would kill PID ${proc.pid}: ${proc.command}`);\n      continue;\n    }\n\n    try {\n      process.kill(proc.pid, 'SIGTERM');\n      result.killed.push(proc.pid);\n      logger.info(`Killed stale process ${proc.pid}: ${proc.command}`);\n    } catch (error: unknown) {\n      const err = error as NodeJS.ErrnoException;\n      if (err.code === 'ESRCH') {\n        // Process already dead\n        result.killed.push(proc.pid);\n      } else {\n        result.errors.push({\n          pid: proc.pid,\n          error: err.message || 'Unknown error',\n        });\n        logger.warn(`Failed to kill PID ${proc.pid}:`, err.message);\n      }\n    }\n  }\n\n  return result;\n}\n\n/**\n * Main cleanup function\n */\nexport function cleanupStaleProcesses(\n  options: {\n    maxAgeHours?: number;\n    dryRun?: boolean;\n  } = {}\n): CleanupResult {\n  const { maxAgeHours = 24, dryRun = false } = options;\n\n  logger.info(`Looking for stale processes older than ${maxAgeHours}h...`);\n\n  const staleProcesses = findStaleProcesses(maxAgeHours);\n\n  if (staleProcesses.length === 0) {\n    logger.info('No stale processes found');\n    return { found: [], killed: [], errors: [] };\n  }\n\n  logger.info(`Found ${staleProcesses.length} stale process(es)`);\n\n  return killStaleProcesses(staleProcesses, dryRun);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "0.5.58",
+  "version": "0.5.59",
   "description": "Lossless memory runtime for AI coding tools - organizes context as a call stack instead of linear chat logs, with team collaboration and infinite retention",
   "engines": {
     "node": ">=20.0.0",
@@ -64,7 +64,7 @@
     "prepublishOnly": "npm run build && npm run test:pre-publish",
     "quality": "npm run lint && npm run test:run && npm run build",
     "dev": "tsx watch src/mcp/mcp-server.ts",
-    "mcp:start": "node dist/src/integrations/mcp/server.js",
+    "mcp:start": "node dist/integrations/mcp/server.js",
     "mcp:dev": "tsx src/mcp/mcp-server.ts",
     "status": "node dist/scripts/status.js",
     "linear:sync": "node scripts/sync-linear-graphql.js",
@@ -89,7 +89,7 @@
     "@browsermcp/mcp": "^0.1.3",
     "@google-cloud/storage": "^7.18.0",
     "@linear/sdk": "^68.1.0",
-    "@modelcontextprotocol/sdk": "^0.5.0",
+    "@modelcontextprotocol/sdk": "^1.25.3",
     "@stackmemoryai/stackmemory": "^0.3.19",
     "@types/blessed": "^0.1.27",
     "@types/inquirer": "^9.0.9",

package/scripts/initialize.ts

@@ -83,19 +83,28 @@ if (!existsSync(jsonlPath)) {
 }
 
 // 5. Create MCP config for Claude Code
-const mcpConfigPath = join(
-  process.env['HOME'] || '~',
-  '.config',
-  'claude',
-  'mcp.json'
-);
+const isMacOS = process.platform === 'darwin';
+const mcpConfigPath = isMacOS
+  ? join(
+      process.env['HOME'] || '~',
+      'Library',
+      'Application Support',
+      'Claude',
+      'claude_desktop_config.json'
+    )
+  : join(
+      process.env['HOME'] || '~',
+      '.config',
+      'claude',
+      'claude_desktop_config.json'
+    );
 console.log(chalk.blue('\n📝 MCP Configuration for Claude Code:\n'));
 
 const mcpConfig = {
   mcpServers: {
     stackmemory: {
       command: 'node',
-      args: [join(projectRoot, 'dist', 'mcp-server.js')],
+      args: [join(projectRoot, 'dist', 'integrations', 'mcp', 'server.js')],
       env: {
         PROJECT_ROOT: projectRoot,
       },

package/scripts/install.sh

@@ -43,10 +43,12 @@ mkdir -p "$INSTALL_DIR"
 
 # Copy all necessary files
 cp -r "$CURRENT_DIR/src" "$INSTALL_DIR/" 2>/dev/null || true
-cp -r "$CURRENT_DIR/attention-scoring" "$INSTALL_DIR/" 2>/dev/null || true  
+cp -r "$CURRENT_DIR/scripts" "$INSTALL_DIR/" 2>/dev/null || true
+cp -r "$CURRENT_DIR/attention-scoring" "$INSTALL_DIR/" 2>/dev/null || true
 cp -r "$CURRENT_DIR/p2p-sync" "$INSTALL_DIR/" 2>/dev/null || true
 cp "$CURRENT_DIR/package.json" "$INSTALL_DIR/"
 cp "$CURRENT_DIR/tsconfig.json" "$INSTALL_DIR/"
+cp "$CURRENT_DIR/esbuild.config.js" "$INSTALL_DIR/"
 
 # 2. Install dependencies
 echo -e "${GREEN}[2/5]${NC} Installing dependencies..."
@@ -90,7 +92,7 @@ for CONFIG_DIR in "$MCP_CONFIG_DIR" "$ALT_MCP_DIR"; do
         
         config.mcpServers.stackmemory = {
             command: 'node',
-            args: ['$INSTALL_DIR/dist/src/mcp-server.js'],
+            args: ['$INSTALL_DIR/dist/integrations/mcp/server.js'],
             env: {
                 STACKMEMORY_GLOBAL: 'true'
             }
@@ -106,7 +108,7 @@ for CONFIG_DIR in "$MCP_CONFIG_DIR" "$ALT_MCP_DIR"; do
   "mcpServers": {
     "stackmemory": {
       "command": "node",
-      "args": ["$INSTALL_DIR/dist/src/mcp-server.js"],
+      "args": ["$INSTALL_DIR/dist/integrations/mcp/server.js"],
       "env": {
         "STACKMEMORY_GLOBAL": "true"
       }
@@ -124,75 +126,25 @@ echo -e "${GREEN}[5/5]${NC} Creating global command..."
 # Create bin directory if it doesn't exist
 mkdir -p "$HOME/.local/bin"
 
-# Create the global stackmemory command
+# Create the global stackmemory command - delegates to the real CLI
 cat > "$HOME/.local/bin/stackmemory" << 'EOF'
 #!/usr/bin/env node
 
 const { spawn } = require('child_process');
 const path = require('path');
-const fs = require('fs');
 const os = require('os');
 
 const installDir = path.join(os.homedir(), '.stackmemory');
-const mcpServer = path.join(installDir, 'dist', 'src', 'mcp-server.js');
-
-// Check if we're in a git repo
-function isGitRepo() {
-    try {
-        require('child_process').execSync('git rev-parse --git-dir', { stdio: 'ignore' });
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
+const cliPath = path.join(installDir, 'dist', 'cli', 'index.js');
 
-// Auto-initialize if in git repo
-if (isGitRepo() && !fs.existsSync('.stackmemory')) {
-    console.log('🎯 Initializing StackMemory in this repository...');
-    
-    fs.mkdirSync('.stackmemory', { recursive: true });
-    
-    const config = {
-        projectId: path.basename(process.cwd()),
-        userId: process.env.USER || 'default',
-        initialized: new Date().toISOString()
-    };
-    
-    fs.writeFileSync('.stackmemory/config.json', JSON.stringify(config, null, 2));
-    fs.writeFileSync('.stackmemory/frames.jsonl', '');
-    
-    // Add to .gitignore
-    if (fs.existsSync('.gitignore')) {
-        const gitignore = fs.readFileSync('.gitignore', 'utf8');
-        if (!gitignore.includes('.stackmemory')) {
-            fs.appendFileSync('.gitignore', '\n# StackMemory\n.stackmemory/*.db\n.stackmemory/*.db-*\n');
-        }
-    }
-    
-    console.log('✅ StackMemory initialized!');
-}
+// Pass all arguments to the real CLI
+const args = process.argv.slice(2);
+const child = spawn('node', [cliPath, ...args], {
+    env: { ...process.env, PROJECT_ROOT: process.cwd() },
+    stdio: 'inherit'
+});
 
-// Handle commands
-const command = process.argv[2];
-
-switch(command) {
-    case 'init':
-        // Already handled above
-        break;
-    case 'status':
-        require(path.join(installDir, 'dist', 'scripts', 'status.js'));
-        break;
-    case 'test':
-        require(path.join(installDir, 'dist', 'test', 'test-framework.js'));
-        break;
-    default:
-        // Start MCP server
-        const child = spawn('node', [mcpServer], {
-            env: { ...process.env, PROJECT_ROOT: process.cwd() },
-            stdio: 'inherit'
-        });
-        child.on('exit', code => process.exit(code));
-}
+child.on('exit', code => process.exit(code || 0));
 EOF
 
 chmod +x "$HOME/.local/bin/stackmemory"

package/scripts/status.ts

@@ -4,7 +4,7 @@
  */
 
 import Database from 'better-sqlite3';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
 
@@ -20,7 +20,8 @@ interface ContextRow {
 }
 
 interface FrameRow {
-  task: string;
+  name: string;
+  type: string;
   started: string;
 }
 
@@ -30,18 +31,46 @@ interface AttentionRow {
 }
 
 const projectRoot = process.cwd();
-const dbPath = join(projectRoot, '.stackmemory', 'context.db');
+const stackDir = join(projectRoot, '.stackmemory');
+const dbPath = join(stackDir, 'context.db');
+const configPath = join(stackDir, 'config.json');
+
+// Check if .stackmemory directory exists
+console.log(chalk.blue.bold('\n[StackMemory Status]\n'));
 
+if (!existsSync(stackDir)) {
+  console.log(chalk.red('[X] .stackmemory directory not found'));
+  console.log(chalk.gray('    Run: stackmemory init'));
+  process.exit(1);
+}
+console.log(chalk.green('[OK] .stackmemory directory exists'));
+
+// Show config.json contents
+if (existsSync(configPath)) {
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    console.log(chalk.green('[OK] config.json found'));
+    console.log(chalk.gray(`    version: ${config.version || 'unknown'}`));
+    console.log(chalk.gray(`    project: ${config.project || 'unknown'}`));
+    console.log(
+      chalk.gray(`    initialized: ${config.initialized || 'unknown'}`)
+    );
+  } catch {
+    console.log(chalk.yellow('[!] config.json exists but failed to parse'));
+  }
+} else {
+  console.log(chalk.yellow('[!] config.json not found'));
+}
+
+// Check database
 if (!existsSync(dbPath)) {
-  console.log(chalk.red('❌ StackMemory not initialized in this project'));
-  console.log(chalk.gray('Run: npm run init'));
+  console.log(chalk.red('[X] context.db not found'));
   process.exit(1);
 }
+console.log(chalk.green('[OK] context.db exists'));
 
 const db = new Database(dbPath, { readonly: true });
 
-console.log(chalk.blue.bold('\n📊 StackMemory Status\n'));
-
 // Get statistics
 const stats = {
   contexts: db
@@ -55,43 +84,45 @@ const stats = {
     .get() as CountResult,
 };
 
-console.log(chalk.green('Database:') + ` ${dbPath}`);
-console.log(chalk.green('Contexts:') + ` ${stats.contexts.count}`);
-console.log(chalk.green('Frames:') + ` ${stats.frames.count}`);
-console.log(chalk.green('Attention logs:') + ` ${stats.attention.count}`);
+console.log(chalk.cyan('\n[Database Stats]'));
+console.log(`    Contexts: ${stats.contexts.count}`);
+console.log(`    Frames: ${stats.frames.count}`);
+console.log(`    Attention logs: ${stats.attention.count}`);
 
 // Get top contexts by importance
-console.log(chalk.blue('\n🎯 Top Contexts by Importance:\n'));
-
-const topContexts = db
-  .prepare(
-    `
-  SELECT type, substr(content, 1, 60) as preview, importance, access_count
-  FROM contexts
-  ORDER BY importance DESC, access_count DESC
-  LIMIT 5
-`
-  )
-  .all() as ContextRow[];
+if (stats.contexts.count > 0) {
+  console.log(chalk.cyan('\n[Top Contexts by Importance]'));
+
+  const topContexts = db
+    .prepare(
+      `
+    SELECT type, substr(content, 1, 60) as preview, importance, access_count
+    FROM contexts
+    ORDER BY importance DESC, access_count DESC
+    LIMIT 5
+  `
+    )
+    .all() as ContextRow[];
 
-topContexts.forEach((ctx, i) => {
-  const importance = '●'.repeat(Math.round(ctx.importance * 5));
-  console.log(
-    chalk.cyan(`${i + 1}.`) +
-      ` [${ctx.type}] ` +
-      chalk.gray(`(${ctx.access_count} uses)`) +
-      ` ${importance}`
-  );
-  console.log(chalk.gray(`   ${ctx.preview}...`));
-});
+  topContexts.forEach((ctx, i) => {
+    const importance = '*'.repeat(Math.round(ctx.importance * 5));
+    console.log(
+      chalk.white(`  ${i + 1}.`) +
+        ` [${ctx.type}] ` +
+        chalk.gray(`(${ctx.access_count} uses)`) +
+        ` ${importance}`
+    );
+    console.log(chalk.gray(`     ${ctx.preview}...`));
+  });
+}
 
-// Get active frames
+// Get active frames (using correct schema: name, type, state)
 const activeFrames = db
   .prepare(
     `
-  SELECT task, datetime(created_at, 'unixepoch') as started
+  SELECT name, type, datetime(created_at, 'unixepoch') as started
   FROM frames
-  WHERE status = 'active'
+  WHERE state = 'active'
   ORDER BY created_at DESC
   LIMIT 3
 `
@@ -99,10 +130,10 @@ const activeFrames = db
   .all() as FrameRow[];
 
 if (activeFrames.length > 0) {
-  console.log(chalk.blue('\n🔄 Active Tasks:\n'));
+  console.log(chalk.cyan('\n[Active Frames]'));
   activeFrames.forEach((frame) => {
-    console.log(chalk.green('•') + ` ${frame.task}`);
-    console.log(chalk.gray(`  Started: ${frame.started}`));
+    console.log(chalk.green('  *') + ` ${frame.name} (${frame.type})`);
+    console.log(chalk.gray(`    Started: ${frame.started}`));
   });
 }
 
@@ -110,7 +141,7 @@ if (activeFrames.length > 0) {
 const recentAttention = db
   .prepare(
     `
-  SELECT 
+  SELECT
     substr(query, 1, 50) as query_preview,
     COUNT(*) as count
   FROM attention_log
@@ -123,10 +154,10 @@ const recentAttention = db
   .all() as AttentionRow[];
 
 if (recentAttention.length > 0) {
-  console.log(chalk.blue('\n👁️ Recent Query Patterns:\n'));
+  console.log(chalk.cyan('\n[Recent Query Patterns]'));
   recentAttention.forEach((pattern) => {
     console.log(
-      chalk.yellow('?') + ` "${pattern.query_preview}..." (${pattern.count}x)`
+      chalk.yellow('  ?') + ` "${pattern.query_preview}..." (${pattern.count}x)`
     );
   });
 }
@@ -145,15 +176,49 @@ const oldContexts = db
 if (oldContexts.count > 0) {
   console.log(
     chalk.yellow(
-      `\n⚠️  ${oldContexts.count} contexts haven't been accessed in 7+ days`
+      `\n[!] ${oldContexts.count} contexts haven't been accessed in 7+ days`
     )
   );
 }
 
+// Check MCP configuration
+console.log(chalk.cyan('\n[MCP Configuration]'));
+const mcpConfigPaths = [
+  join(
+    process.env.HOME || '',
+    'Library/Application Support/Claude/claude_desktop_config.json'
+  ),
+  join(process.env.HOME || '', '.config/claude/claude_desktop_config.json'),
+];
+
+let mcpFound = false;
+for (const mcpPath of mcpConfigPaths) {
+  if (existsSync(mcpPath)) {
+    try {
+      const mcpConfig = JSON.parse(readFileSync(mcpPath, 'utf-8'));
+      const hasStackMemory =
+        mcpConfig.mcpServers?.stackmemory ||
+        mcpConfig.mcpServers?.['stackmemory-mcp'];
+      if (hasStackMemory) {
+        console.log(chalk.green('  [OK] MCP server configured'));
+        mcpFound = true;
+      } else {
+        console.log(
+          chalk.yellow('  [!] MCP config exists but stackmemory not configured')
+        );
+      }
+    } catch {
+      console.log(chalk.yellow(`  [!] Failed to parse ${mcpPath}`));
+    }
+    break;
+  }
+}
+if (!mcpFound) {
+  console.log(chalk.gray('  [--] No MCP configuration found'));
+}
+
 console.log(
-  chalk.gray(
-    '\n💡 Tip: Run "npm run analyze" for detailed attention analysis\n'
-  )
+  chalk.gray('\nTip: Run "npm run analyze" for detailed attention analysis\n')
 );
 
 db.close();