@stackmemoryai/stackmemory 0.5.59 → 0.5.62

package/dist/cli/commands/context-rehydrate.js

@@ -1,751 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import { Command } from "commander";
-import { join } from "path";
-import { existsSync } from "fs";
-import { logger } from "../../core/monitoring/logger.js";
-function createContextRehydrateCommand() {
-  const command = new Command("rehydrate");
-  command.description("Enhanced context rehydration after Claude compaction").option("-c, --checkpoint <id>", "Use specific checkpoint ID").option("--create", "Create new rehydration checkpoint").option("-l, --list", "List available checkpoints").option("-v, --verbose", "Verbose output").option("--verify", "Verify checkpoint contents and integrity").option("--with-traces", "Include stack trace context in output").option("--traces", "Show recent stack traces from database").option("--trace-stats", "Show stack trace statistics and patterns").action(async (options) => {
-    await handleContextRehydrate(options);
-  });
-  return command;
-}
-async function handleContextRehydrate(options) {
-  const projectRoot = process.cwd();
-  const dbPath = join(projectRoot, ".stackmemory", "context.db");
-  if (!existsSync(dbPath)) {
-    console.log('\u274C StackMemory not initialized. Run "stackmemory init" first.');
-    return;
-  }
-  try {
-    console.log("\u{1F504} Enhanced Context Rehydration System");
-    console.log("\u{1F4DA} This system preserves rich context across Claude compactions\n");
-    if (options.list) {
-      await listCheckpoints();
-      return;
-    }
-    if (options.create) {
-      console.log("\u{1F504} Creating rehydration checkpoint...");
-      await createRehydrationCheckpoint(options.withTraces);
-      return;
-    }
-    if (options.verify) {
-      await verifyCheckpoints(options.checkpoint);
-      return;
-    }
-    if (options.traces) {
-      await showStackTraces();
-      return;
-    }
-    if (options.traceStats) {
-      await showStackTraceStats();
-      return;
-    }
-    console.log("\u{1F4BE} Starting context rehydration...");
-    if (options.verbose) {
-      console.log("\u{1F4CB} Analyzing current session state...");
-    }
-    const success = await performRehydration(options.checkpoint);
-    if (success) {
-      console.log("\u2705 Context successfully rehydrated");
-      console.log("\u{1F4CA} Rich context has been injected into current session");
-      if (options.verbose) {
-        console.log("\n\u{1F4C1} Context includes:");
-        console.log("  \u2022 File snapshots with content previews");
-        console.log("  \u2022 Project structure mapping");
-        console.log("  \u2022 Previous decisions and reasoning");
-        console.log("  \u2022 Active workflow detection");
-        console.log("  \u2022 User preferences and pain points");
-      }
-    } else {
-      console.log("\u26A0\uFE0F Context rehydration failed");
-      console.log("\u{1F4A1} Try creating a checkpoint first with --create");
-    }
-  } catch (error) {
-    logger.error("Context rehydration error:", error);
-    console.error("\u274C Failed to rehydrate context:", error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-async function createRehydrationCheckpoint(withTraces = false) {
-  const fs = await import("fs/promises");
-  const checkpointDir = join(process.cwd(), ".stackmemory", "rehydration");
-  try {
-    await fs.mkdir(checkpointDir, { recursive: true });
-    const checkpointId = `checkpoint_${Date.now()}`;
-    const checkpoint = {
-      id: checkpointId,
-      timestamp: Date.now(),
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      working_directory: process.cwd(),
-      recent_files: await getRecentFiles(),
-      project_context: await analyzeProjectContext(),
-      session_info: {
-        pid: process.pid,
-        env: {
-          NODE_ENV: process.env.NODE_ENV,
-          PWD: process.env.PWD
-        }
-      },
-      stack_traces: withTraces ? await captureStackTraces() : [],
-      error_patterns: withTraces ? await detectErrorPatterns() : [],
-      verification: {
-        files_captured: 0,
-        total_size: 0,
-        integrity_hash: ""
-      }
-    };
-    const checkpointPath = join(checkpointDir, `${checkpointId}.json`);
-    await fs.writeFile(checkpointPath, JSON.stringify(checkpoint, null, 2));
-    checkpoint.verification.files_captured = checkpoint.recent_files.length;
-    checkpoint.verification.total_size = checkpoint.recent_files.reduce((sum, file) => sum + file.size, 0);
-    checkpoint.verification.integrity_hash = await calculateCheckpointHash(checkpoint);
-    await fs.writeFile(checkpointPath, JSON.stringify(checkpoint, null, 2));
-    console.log(`\u2705 Created checkpoint: ${checkpointId}`);
-    console.log(`\u{1F4C1} Saved to: ${checkpointPath}`);
-    console.log(`\u{1F4CA} Captured ${checkpoint.recent_files.length} recent files`);
-    if (withTraces) {
-      console.log(`\u{1F41B} Captured ${checkpoint.stack_traces.length} stack traces`);
-      console.log(`\u{1F50D} Detected ${checkpoint.error_patterns.length} error patterns`);
-    }
-  } catch (error) {
-    console.error("\u274C Failed to create checkpoint:", error);
-    throw error;
-  }
-}
-async function performRehydration(checkpointId) {
-  const fs = await import("fs/promises");
-  const checkpointDir = join(process.cwd(), ".stackmemory", "rehydration");
-  try {
-    let checkpoint;
-    if (checkpointId) {
-      const checkpointPath = join(checkpointDir, `${checkpointId}.json`);
-      const content = await fs.readFile(checkpointPath, "utf8");
-      checkpoint = JSON.parse(content);
-    } else {
-      const files = await fs.readdir(checkpointDir);
-      const checkpointFiles = files.filter((f) => f.endsWith(".json"));
-      if (checkpointFiles.length === 0) {
-        console.log("\u{1F4ED} No checkpoints found");
-        return false;
-      }
-      checkpointFiles.sort((a, b) => b.localeCompare(a));
-      const latestFile = checkpointFiles[0];
-      const content = await fs.readFile(join(checkpointDir, latestFile), "utf8");
-      checkpoint = JSON.parse(content);
-    }
-    console.log(`\u{1F504} Rehydrating from checkpoint: ${checkpoint.id}`);
-    console.log(`\u{1F4C5} Created: ${checkpoint.created_at}`);
-    console.log(`\u{1F4C1} Working directory: ${checkpoint.working_directory}`);
-    console.log(`\u{1F4CB} Recent files: ${checkpoint.recent_files.length}`);
-    console.log("\n\u{1F4CA} Context Summary:");
-    checkpoint.recent_files.slice(0, 5).forEach((file, i) => {
-      console.log(`   ${i + 1}. ${file.path} (${file.size} bytes, modified ${new Date(file.mtime).toLocaleString()})`);
-    });
-    if (checkpoint.project_context.key_files.length > 0) {
-      console.log(`
-\u{1F511} Key project files: ${checkpoint.project_context.key_files.join(", ")}`);
-    }
-    return true;
-  } catch (error) {
-    console.error("\u274C Failed to rehydrate:", error);
-    return false;
-  }
-}
-async function getRecentFiles() {
-  const fs = await import("fs/promises");
-  try {
-    const files = await fs.readdir(".", { withFileTypes: true });
-    const recentFiles = [];
-    for (const file of files.slice(0, 20)) {
-      if (file.isFile() && !file.name.startsWith(".")) {
-        try {
-          const stats = await fs.stat(file.name);
-          recentFiles.push({
-            path: file.name,
-            size: stats.size,
-            mtime: stats.mtimeMs
-          });
-        } catch {
-        }
-      }
-    }
-    return recentFiles.sort((a, b) => b.mtime - a.mtime);
-  } catch (error) {
-    console.warn("Could not analyze recent files:", error);
-    return [];
-  }
-}
-async function analyzeProjectContext() {
-  const fs = await import("fs/promises");
-  const context = {
-    key_files: [],
-    project_type: "unknown",
-    framework: "unknown"
-  };
-  try {
-    const projectFiles = ["package.json", "tsconfig.json", "README.md", "docker-compose.yml"];
-    for (const file of projectFiles) {
-      try {
-        await fs.access(file);
-        context.key_files.push(file);
-      } catch {
-      }
-    }
-    if (context.key_files.includes("package.json")) {
-      context.project_type = "node";
-      try {
-        const packageContent = await fs.readFile("package.json", "utf8");
-        const packageJson = JSON.parse(packageContent);
-        if (packageJson.dependencies?.react) {
-          context.framework = "react";
-        } else if (packageJson.dependencies?.vue) {
-          context.framework = "vue";
-        } else if (packageJson.dependencies?.next) {
-          context.framework = "next";
-        }
-      } catch {
-      }
-    }
-  } catch (error) {
-    console.warn("Could not analyze project context:", error);
-  }
-  return context;
-}
-async function listCheckpoints() {
-  try {
-    const checkpointDir = "./.stackmemory/rehydration";
-    const fs = await import("fs/promises");
-    try {
-      const files = await fs.readdir(checkpointDir);
-      const checkpoints = files.filter((f) => f.endsWith(".json"));
-      if (checkpoints.length === 0) {
-        console.log("\u{1F4ED} No rehydration checkpoints found");
-        console.log("\u{1F4A1} Create one with: stackmemory context rehydrate --create");
-        return;
-      }
-      console.log(`\u{1F4CB} Found ${checkpoints.length} rehydration checkpoint(s):
-`);
-      for (const file of checkpoints) {
-        const id = file.replace(".json", "");
-        const stats = await fs.stat(`${checkpointDir}/${file}`);
-        try {
-          const content = await fs.readFile(`${checkpointDir}/${file}`, "utf8");
-          const checkpoint = JSON.parse(content);
-          console.log(`\u{1F516} ${id}`);
-          console.log(`   Created: ${stats.birthtime.toISOString()}`);
-          console.log(`   Size: ${(stats.size / 1024).toFixed(1)} KB`);
-          console.log(`   Files: ${checkpoint.verification?.files_captured || checkpoint.recent_files?.length || 0}`);
-          if (checkpoint.stack_traces?.length > 0) {
-            console.log(`   Stack traces: ${checkpoint.stack_traces.length}`);
-          }
-          if (checkpoint.error_patterns?.length > 0) {
-            console.log(`   Error patterns: ${checkpoint.error_patterns.length}`);
-          }
-          console.log("");
-        } catch {
-          console.log(`\u{1F516} ${id}`);
-          console.log(`   Created: ${stats.birthtime.toISOString()}`);
-          console.log(`   Size: ${(stats.size / 1024).toFixed(1)} KB
-`);
-        }
-      }
-      console.log("\u{1F4A1} Use: stackmemory context rehydrate -c <checkpoint-id>");
-      console.log("\u{1F4A1} Verify: stackmemory context rehydrate --verify -c <checkpoint-id>");
-    } catch (err) {
-      console.log("\u{1F4ED} No rehydration checkpoints directory found");
-      console.log("\u{1F4A1} Create first checkpoint with: stackmemory context rehydrate --create");
-    }
-  } catch (error) {
-    console.error("\u274C Failed to list checkpoints:", error);
-  }
-}
-async function verifyCheckpoints(checkpointId) {
-  try {
-    const checkpointDir = "./.stackmemory/rehydration";
-    const fs = await import("fs/promises");
-    if (checkpointId) {
-      const checkpointPath = `${checkpointDir}/${checkpointId}.json`;
-      await verifyCheckpoint(checkpointPath);
-    } else {
-      const files = await fs.readdir(checkpointDir);
-      const checkpoints = files.filter((f) => f.endsWith(".json"));
-      console.log(`\u{1F50D} Verifying ${checkpoints.length} checkpoint(s)...
-`);
-      for (const file of checkpoints) {
-        await verifyCheckpoint(`${checkpointDir}/${file}`);
-        console.log("");
-      }
-    }
-  } catch (error) {
-    console.error("\u274C Failed to verify checkpoints:", error);
-  }
-}
-async function verifyCheckpoint(checkpointPath) {
-  const fs = await import("fs/promises");
-  try {
-    const content = await fs.readFile(checkpointPath, "utf8");
-    const checkpoint = JSON.parse(content);
-    const fileName = checkpointPath.split("/").pop()?.replace(".json", "") || "unknown";
-    console.log(`\u{1F50D} Verifying checkpoint: ${fileName}`);
-    const requiredFields = ["id", "timestamp", "working_directory", "recent_files"];
-    const missingFields = requiredFields.filter((field) => !checkpoint[field]);
-    if (missingFields.length > 0) {
-      console.log(`\u274C Missing required fields: ${missingFields.join(", ")}`);
-      return;
-    }
-    console.log(`\u{1F4C1} Files captured: ${checkpoint.recent_files?.length || 0}`);
-    if (checkpoint.verification) {
-      console.log(`\u{1F4CA} Total size: ${(checkpoint.verification.total_size / 1024).toFixed(1)} KB`);
-      console.log(`\u{1F512} Integrity hash: ${checkpoint.verification.integrity_hash.slice(0, 12)}...`);
-      const recalculatedHash = await calculateCheckpointHash(checkpoint);
-      if (recalculatedHash === checkpoint.verification.integrity_hash) {
-        console.log(`\u2705 Integrity check: PASSED`);
-      } else {
-        console.log(`\u274C Integrity check: FAILED (data may be corrupted)`);
-      }
-    }
-    if (checkpoint.stack_traces) {
-      console.log(`\u{1F41B} Stack traces: ${checkpoint.stack_traces.length}`);
-      const pendingTraces = checkpoint.stack_traces.filter((t) => t.resolution_status === "pending");
-      const resolvedTraces = checkpoint.stack_traces.filter((t) => t.resolution_status === "resolved");
-      if (pendingTraces.length > 0) {
-        console.log(`   \u23F3 Pending resolution: ${pendingTraces.length}`);
-      }
-      if (resolvedTraces.length > 0) {
-        console.log(`   \u2705 Resolved: ${resolvedTraces.length}`);
-      }
-    }
-    if (checkpoint.error_patterns?.length > 0) {
-      console.log(`\u{1F50D} Error patterns detected: ${checkpoint.error_patterns.join(", ")}`);
-    }
-    console.log(`\u2705 Checkpoint verification complete`);
-  } catch (error) {
-    console.log(`\u274C Failed to verify checkpoint: ${error}`);
-  }
-}
-async function captureStackTraces() {
-  try {
-    const traces = [];
-    const fs = await import("fs/promises");
-    const { execSync } = await import("child_process");
-    const stackMemoryLogs = [
-      ".stackmemory/error.log",
-      ".stackmemory/compaction.log",
-      ".stackmemory/trace.log",
-      ".stackmemory/debug.log"
-    ];
-    const nodeLogs = [
-      "npm-debug.log",
-      "error.log",
-      "debug.log",
-      "yarn-error.log",
-      "pnpm-debug.log"
-    ];
-    const buildLogs = [
-      "build-errors.log",
-      "webpack-errors.log",
-      "vite-errors.log",
-      "jest-errors.log",
-      "test-results.log"
-    ];
-    const frameworkLogs = [
-      ".next/trace",
-      "logs/error.log",
-      "tmp/cache/error.log"
-    ];
-    const allLogFiles = [...stackMemoryLogs, ...nodeLogs, ...buildLogs, ...frameworkLogs];
-    for (const logFile of allLogFiles) {
-      await extractTracesFromLogFile(logFile, traces, fs);
-    }
-    await extractFromTerminalHistory(traces);
-    await extractFromClaudeSession(traces, fs);
-    await extractFromBuildCommands(traces);
-    await extractFromGitLogs(traces);
-    await extractFromBrowserLogs(traces, fs);
-    return traces;
-  } catch {
-    return [];
-  }
-}
-async function detectErrorPatterns() {
-  const traces = await captureStackTraces();
-  const patterns = /* @__PURE__ */ new Map();
-  for (const trace of traces) {
-    const errorType = trace.error_message.split(":")[0].trim();
-    patterns.set(errorType, (patterns.get(errorType) || 0) + 1);
-  }
-  return Array.from(patterns.entries()).filter(([, count]) => count > 1).map(([pattern]) => pattern);
-}
-async function extractTracesFromLogFile(logFile, traces, fs) {
-  try {
-    const logContent = await fs.readFile(logFile, "utf8");
-    const lines = logContent.split("\n");
-    const errorPatterns = [
-      /Error:/i,
-      /TypeError:/i,
-      /ReferenceError:/i,
-      /SyntaxError:/i,
-      /RangeError:/i,
-      /URIError:/i,
-      /EvalError:/i,
-      /UnhandledPromiseRejectionWarning:/i,
-      /DeprecationWarning:/i,
-      /\s+at\s+/,
-      // Stack trace lines
-      /Failed to compile/i,
-      /Build failed/i,
-      /Test failed/i
-    ];
-    let currentError = null;
-    let stackFrames = [];
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (errorPatterns.some((pattern) => pattern.test(line))) {
-        if (currentError && stackFrames.length > 0) {
-          traces.push({
-            ...currentError,
-            stack_frames: [...stackFrames],
-            file_path: logFile,
-            timestamp: Date.now(),
-            context: `Extracted from ${logFile} around line ${i}`,
-            resolution_status: "pending"
-          });
-        }
-        if (line.includes("Error:") || line.includes("TypeError:")) {
-          currentError = {
-            error_message: line.trim()
-          };
-          stackFrames = [line.trim()];
-        } else if (line.includes("at ")) {
-          stackFrames.push(line.trim());
-        }
-      } else if (currentError && line.includes("at ")) {
-        stackFrames.push(line.trim());
-      }
-    }
-    if (currentError && stackFrames.length > 0) {
-      traces.push({
-        ...currentError,
-        stack_frames: [...stackFrames],
-        file_path: logFile,
-        timestamp: Date.now(),
-        context: `Extracted from ${logFile}`,
-        resolution_status: "pending"
-      });
-    }
-  } catch {
-  }
-}
-async function extractFromTerminalHistory(traces) {
-  try {
-    const { execSync } = await import("child_process");
-    const historyCommands = [
-      "npm run build 2>&1 | tail -50",
-      "npm test 2>&1 | tail -50",
-      "npm start 2>&1 | tail -50"
-    ];
-    for (const cmd of historyCommands) {
-      try {
-        const output = execSync(cmd, { encoding: "utf8", timeout: 5e3 });
-        if (output.includes("Error:") || output.includes("failed")) {
-          const errorLines = output.split("\n").filter(
-            (line) => line.includes("Error:") || line.includes("at ") || line.includes("failed")
-          );
-          if (errorLines.length > 0) {
-            traces.push({
-              error_message: errorLines[0],
-              stack_frames: errorLines,
-              file_path: "terminal_output",
-              timestamp: Date.now(),
-              context: `Recent command: ${cmd}`,
-              resolution_status: "pending"
-            });
-          }
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-}
-async function extractFromClaudeSession(traces, fs) {
-  try {
-    const claudePaths = [
-      "~/.claude/logs",
-      "~/.local/share/claude/logs",
-      "/tmp/claude-logs",
-      ".claude-logs"
-    ];
-    for (const logPath of claudePaths) {
-      try {
-        const files = await fs.readdir(logPath);
-        const recentLogs = files.filter((f) => f.endsWith(".log")).slice(-5);
-        for (const logFile of recentLogs) {
-          await extractTracesFromLogFile(`${logPath}/${logFile}`, traces, fs);
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-}
-async function extractFromBuildCommands(traces) {
-  try {
-    const { execSync } = await import("child_process");
-    const buildCommands = [
-      "npm run lint --silent",
-      "npm run typecheck --silent",
-      "npx tsc --noEmit --skipLibCheck"
-    ];
-    for (const cmd of buildCommands) {
-      try {
-        execSync(cmd, { encoding: "utf8", timeout: 1e4 });
-      } catch (error) {
-        if (error.stdout || error.stderr) {
-          const output = error.stdout + error.stderr;
-          const errorLines = output.split("\n").filter(
-            (line) => line.includes("Error:") || line.includes("at ") || line.includes("error TS")
-          );
-          if (errorLines.length > 0) {
-            traces.push({
-              error_message: errorLines[0] || `Build command failed: ${cmd}`,
-              stack_frames: errorLines,
-              file_path: "build_output",
-              timestamp: Date.now(),
-              context: `Build command: ${cmd}`,
-              resolution_status: "pending"
-            });
-          }
-        }
-      }
-    }
-  } catch {
-  }
-}
-async function extractFromGitLogs(traces) {
-  try {
-    const { execSync } = await import("child_process");
-    const gitOutput = execSync(
-      'git log --oneline -10 --grep="fix\\|error\\|bug" 2>/dev/null || echo "No git history"',
-      { encoding: "utf8", timeout: 5e3 }
-    );
-    if (gitOutput.includes("fix") || gitOutput.includes("error")) {
-      traces.push({
-        error_message: "Recent git commits indicate error fixes",
-        stack_frames: gitOutput.split("\n").filter((line) => line.trim()),
-        file_path: "git_history",
-        timestamp: Date.now(),
-        context: "Git commit history analysis",
-        resolution_status: "resolved"
-        // These are likely fixed
-      });
-    }
-  } catch {
-  }
-}
-async function extractFromBrowserLogs(traces, fs) {
-  try {
-    const browserLogPaths = [
-      "console.log",
-      "browser-errors.log",
-      "dev-server.log",
-      ".vscode/dev-console.log",
-      "tmp/browser-console.log"
-    ];
-    for (const logPath of browserLogPaths) {
-      try {
-        const logContent = await fs.readFile(logPath, "utf8");
-        const browserPatterns = [
-          /console\.error/i,
-          /Uncaught \w+Error/i,
-          /Promise rejection/i,
-          /React\s+Warning/i,
-          /Failed to load/i
-        ];
-        const lines = logContent.split("\n");
-        for (const line of lines) {
-          if (browserPatterns.some((pattern) => pattern.test(line))) {
-            traces.push({
-              error_message: line.trim(),
-              stack_frames: [line.trim()],
-              file_path: logPath,
-              timestamp: Date.now(),
-              context: "Browser console error",
-              resolution_status: "pending"
-            });
-          }
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-}
-async function showStackTraces() {
-  try {
-    const projectRoot = process.cwd();
-    const dbPath = join(projectRoot, ".stackmemory", "context.db");
-    if (!existsSync(dbPath)) {
-      console.log('\u274C StackMemory not initialized. Run "stackmemory init" first.');
-      return;
-    }
-    const Database = (await import("better-sqlite3")).default;
-    const db = new Database(dbPath);
-    try {
-      const tableExists = db.prepare(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name='stack_traces'
-      `).get();
-      if (!tableExists) {
-        console.log("\u{1F4ED} No stack traces found in database");
-        console.log("\u{1F4A1} Stack traces are stored when using enhanced rehydration features");
-        return;
-      }
-      const traces = db.prepare(`
-        SELECT * FROM stack_traces 
-        ORDER BY created_at DESC 
-        LIMIT 20
-      `).all();
-      if (traces.length === 0) {
-        console.log("\u{1F4ED} No stack traces found in database");
-        return;
-      }
-      console.log(`\u{1F41B} Recent Stack Traces (${traces.length} found)
-`);
-      for (const trace of traces) {
-        const createdAt = new Date(trace.created_at * 1e3).toLocaleString();
-        const severity = trace.error_severity || "medium";
-        const severityIcon = severity === "high" ? "\u{1F534}" : severity === "low" ? "\u{1F7E1}" : "\u{1F7E0}";
-        console.log(`${severityIcon} ${trace.error_type || "Error"} - ${severity.toUpperCase()}`);
-        console.log(`   Message: ${trace.error_message}`);
-        console.log(`   File: ${trace.file_path || "unknown"}${trace.line_number ? `:${trace.line_number}` : ""}`);
-        console.log(`   Function: ${trace.function_name || "unknown"}`);
-        console.log(`   Status: ${trace.resolution_status}`);
-        console.log(`   Created: ${createdAt}`);
-        console.log(`   Context: ${trace.context || "No context"}`);
-        const stackFrames = JSON.parse(trace.stack_frames || "[]");
-        if (stackFrames.length > 0) {
-          console.log(`   Stack (first 3 lines):`);
-          stackFrames.slice(0, 3).forEach((frame) => {
-            console.log(`     ${frame.trim()}`);
-          });
-        }
-        console.log("");
-      }
-      console.log("\u{1F4A1} Use --trace-stats for statistics and patterns");
-    } finally {
-      db.close();
-    }
-  } catch (error) {
-    console.error("\u274C Failed to show stack traces:", error);
-  }
-}
-async function showStackTraceStats() {
-  try {
-    const projectRoot = process.cwd();
-    const dbPath = join(projectRoot, ".stackmemory", "context.db");
-    if (!existsSync(dbPath)) {
-      console.log('\u274C StackMemory not initialized. Run "stackmemory init" first.');
-      return;
-    }
-    const Database = (await import("better-sqlite3")).default;
-    const db = new Database(dbPath);
-    try {
-      const tableExists = db.prepare(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name='stack_traces'
-      `).get();
-      if (!tableExists) {
-        console.log("\u{1F4ED} No stack trace data available");
-        return;
-      }
-      console.log("\u{1F4CA} Stack Trace Statistics\n");
-      const totalTraces = db.prepare("SELECT COUNT(*) as count FROM stack_traces").get().count;
-      console.log(`Total traces: ${totalTraces}`);
-      const statusStats = db.prepare(`
-        SELECT resolution_status, COUNT(*) as count 
-        FROM stack_traces 
-        GROUP BY resolution_status 
-        ORDER BY count DESC
-      `).all();
-      console.log("\n\u{1F4C8} By Resolution Status:");
-      for (const stat of statusStats) {
-        const percentage = (stat.count / totalTraces * 100).toFixed(1);
-        console.log(`   ${stat.resolution_status}: ${stat.count} (${percentage}%)`);
-      }
-      const typeStats = db.prepare(`
-        SELECT error_type, COUNT(*) as count 
-        FROM stack_traces 
-        GROUP BY error_type 
-        ORDER BY count DESC 
-        LIMIT 10
-      `).all();
-      console.log("\n\u{1F50D} Top Error Types:");
-      for (const stat of typeStats) {
-        const percentage = (stat.count / totalTraces * 100).toFixed(1);
-        console.log(`   ${stat.error_type}: ${stat.count} (${percentage}%)`);
-      }
-      const severityStats = db.prepare(`
-        SELECT error_severity, COUNT(*) as count 
-        FROM stack_traces 
-        GROUP BY error_severity 
-        ORDER BY 
-          CASE error_severity 
-            WHEN 'high' THEN 1 
-            WHEN 'medium' THEN 2 
-            WHEN 'low' THEN 3 
-          END
-      `).all();
-      console.log("\n\u26A0\uFE0F By Severity:");
-      for (const stat of severityStats) {
-        const percentage = (stat.count / totalTraces * 100).toFixed(1);
-        const icon = stat.error_severity === "high" ? "\u{1F534}" : stat.error_severity === "low" ? "\u{1F7E1}" : "\u{1F7E0}";
-        console.log(`   ${icon} ${stat.error_severity}: ${stat.count} (${percentage}%)`);
-      }
-      const recentTraces = db.prepare(`
-        SELECT COUNT(*) as count 
-        FROM stack_traces 
-        WHERE created_at > (unixepoch() - 86400)
-      `).get().count;
-      console.log(`
-\u{1F4C5} Recent Activity (24 hours): ${recentTraces} traces`);
-      const fileStats = db.prepare(`
-        SELECT file_path, COUNT(*) as count 
-        FROM stack_traces 
-        WHERE file_path IS NOT NULL 
-        GROUP BY file_path 
-        ORDER BY count DESC 
-        LIMIT 5
-      `).all();
-      if (fileStats.length > 0) {
-        console.log("\n\u{1F5C2}\uFE0F Most Problematic Files:");
-        for (const stat of fileStats) {
-          console.log(`   ${stat.file_path}: ${stat.count} errors`);
-        }
-      }
-    } finally {
-      db.close();
-    }
-  } catch (error) {
-    console.error("\u274C Failed to show stack trace statistics:", error);
-  }
-}
-async function calculateCheckpointHash(checkpoint) {
-  const crypto = await import("crypto");
-  const data = JSON.stringify({
-    id: checkpoint.id,
-    timestamp: checkpoint.timestamp,
-    files_count: checkpoint.recent_files?.length || 0,
-    project_context: checkpoint.project_context,
-    stack_traces_count: checkpoint.stack_traces?.length || 0
-  });
-  return crypto.createHash("sha256").update(data).digest("hex");
-}
-export {
-  createContextRehydrateCommand
-};
-//# sourceMappingURL=context-rehydrate.js.map