@ulrichc1/sparn 1.1.1 → 1.2.0

package/dist/cli/index.js

@@ -358,7 +358,8 @@ var init_config = __esm({
         logFile: ".sparn/daemon.log",
         debounceMs: 5e3,
         incremental: true,
-        windowSize: 500
+        windowSize: 500,
+        consolidationInterval: null
       }
     };
   }
@@ -918,16 +919,16 @@ __export(optimize_exports, {
 import { readFile, writeFile as writeFile2 } from "fs/promises";
 async function optimizeCommand(options) {
   const { memory, dryRun = false, verbose = false } = options;
-  let input;
+  let input2;
   if (options.inputFile) {
-    input = await readFile(options.inputFile, "utf-8");
+    input2 = await readFile(options.inputFile, "utf-8");
   } else if (options.input) {
-    input = options.input;
+    input2 = options.input;
   } else {
     throw new Error("No input provided. Use --input or --input-file");
   }
   const adapter = createGenericAdapter(memory, DEFAULT_CONFIG);
-  const result = await adapter.optimize(input, { dryRun, verbose });
+  const result = await adapter.optimize(input2, { dryRun, verbose });
   if (options.outputFile) {
     await writeFile2(options.outputFile, result.optimizedContext, "utf-8");
   }
@@ -1058,7 +1059,7 @@ async function relayCommand(options) {
   return result;
 }
 function executeCommand(command, args) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const child = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -1071,14 +1072,14 @@ function executeCommand(command, args) {
       stderr += data.toString();
     });
     child.on("close", (code) => {
-      resolve2({
+      resolve3({
         stdout,
         stderr,
         exitCode: code ?? 0
       });
     });
     child.on("error", (error) => {
-      resolve2({
+      resolve3({
         stdout,
         stderr: error.message,
         exitCode: 1
@@ -1740,7 +1741,7 @@ function createDaemonCommand() {
       while (waited < maxWait) {
         try {
           process.kill(status2.pid, 0);
-          await new Promise((resolve2) => setTimeout(resolve2, interval));
+          await new Promise((resolve3) => setTimeout(resolve3, interval));
           waited += interval;
         } catch {
           removePidFile(pidFile);
@@ -1963,22 +1964,526 @@ var init_hooks = __esm({
   }
 });
 
+// src/cli/commands/interactive.ts
+var interactive_exports = {};
+__export(interactive_exports, {
+  interactiveCommand: () => interactiveCommand
+});
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { resolve } from "path";
+import { confirm, input, number, select } from "@inquirer/prompts";
+import { load as parseYAML2, dump as stringifyYAML2 } from "js-yaml";
+function showWelcomeBanner() {
+  console.log(brainPink("\n\u2501".repeat(60)));
+  console.log(brainPink("  \u{1F9E0} Sparn Interactive Mode"));
+  console.log(brainPink("\u2501".repeat(60)));
+  console.log(dim("  Conversational configuration and exploration\n"));
+}
+async function showMainMenu() {
+  return select({
+    message: "What would you like to do?",
+    choices: [
+      {
+        name: "\u2699\uFE0F  Configure Settings",
+        value: "configure",
+        description: "Guided configuration wizard"
+      },
+      {
+        name: "\u{1F50D} Optimize Preview",
+        value: "preview",
+        description: "Preview optimization with confirmation"
+      },
+      {
+        name: "\u{1F4CA} Stats Dashboard",
+        value: "stats",
+        description: "View metrics and performance data"
+      },
+      {
+        name: "\u{1F9F9} Memory Consolidation",
+        value: "consolidate",
+        description: "Clean up decayed entries and duplicates"
+      },
+      {
+        name: "\u{1F680} Quick Actions",
+        value: "quick",
+        description: "Common tasks and shortcuts"
+      },
+      {
+        name: "\u274C Exit",
+        value: "exit",
+        description: "Return to shell"
+      }
+    ]
+  });
+}
+async function configureWizard(configPath) {
+  console.log(neuralCyan("\n\u{1F4DD} Configuration Wizard\n"));
+  const configYAML = readFileSync5(configPath, "utf-8");
+  const config = parseYAML2(configYAML);
+  const section = await select({
+    message: "Which settings would you like to configure?",
+    choices: [
+      { name: "\u{1F52A} Pruning (Sparse Coding)", value: "pruning" },
+      { name: "\u23F3 Decay (Engram Theory)", value: "decay" },
+      { name: "\u{1F3AF} States (Multi-State Synapses)", value: "states" },
+      { name: "\u26A1 Real-time Optimization", value: "realtime" },
+      { name: "\u{1F3A8} UI Preferences", value: "ui" },
+      { name: "\u2190 Back to Main Menu", value: "back" }
+    ]
+  });
+  if (section === "back") return;
+  switch (section) {
+    case "pruning": {
+      console.log(synapseViolet("\n\u{1F52A} Pruning Configuration"));
+      console.log(dim("Sparse coding: Keep only the most relevant context\n"));
+      const threshold = await number({
+        message: "Pruning threshold (percentage of entries to keep):",
+        default: config.pruning.threshold,
+        min: 1,
+        max: 100
+      });
+      const aggressiveness = await number({
+        message: "Aggressiveness (0-100, affects TF-IDF weighting):",
+        default: config.pruning.aggressiveness,
+        min: 0,
+        max: 100
+      });
+      config.pruning.threshold = threshold ?? config.pruning.threshold;
+      config.pruning.aggressiveness = aggressiveness ?? config.pruning.aggressiveness;
+      console.log(neuralCyan("\n\u2713 Pruning settings updated"));
+      break;
+    }
+    case "decay": {
+      console.log(synapseViolet("\n\u23F3 Decay Configuration"));
+      console.log(dim("Engram theory: Apply time-based decay to memories\n"));
+      const defaultTTL = await number({
+        message: "Default TTL in hours:",
+        default: config.decay.defaultTTL,
+        min: 1
+      });
+      const decayThreshold = await number({
+        message: "Decay threshold (0.0-1.0, entries below this are pruned):",
+        default: config.decay.decayThreshold,
+        min: 0,
+        max: 1,
+        step: 0.05
+      });
+      config.decay.defaultTTL = defaultTTL ?? config.decay.defaultTTL;
+      config.decay.decayThreshold = decayThreshold ?? config.decay.decayThreshold;
+      console.log(neuralCyan("\n\u2713 Decay settings updated"));
+      break;
+    }
+    case "states": {
+      console.log(synapseViolet("\n\u{1F3AF} State Threshold Configuration"));
+      console.log(dim("Multi-state synapses: Classify entries as active/ready/silent\n"));
+      const activeThreshold = await number({
+        message: "Active state threshold (0.0-1.0):",
+        default: config.states.activeThreshold,
+        min: 0,
+        max: 1,
+        step: 0.05
+      });
+      const readyThreshold = await number({
+        message: "Ready state threshold (0.0-1.0):",
+        default: config.states.readyThreshold,
+        min: 0,
+        max: 1,
+        step: 0.05
+      });
+      config.states.activeThreshold = activeThreshold ?? config.states.activeThreshold;
+      config.states.readyThreshold = readyThreshold ?? config.states.readyThreshold;
+      console.log(neuralCyan("\n\u2713 State settings updated"));
+      break;
+    }
+    case "realtime": {
+      console.log(synapseViolet("\n\u26A1 Real-time Optimization Configuration"));
+      console.log(dim("Daemon settings for automatic optimization\n"));
+      const tokenBudget = await number({
+        message: "Target token budget:",
+        default: config.realtime.tokenBudget,
+        min: 1e3
+      });
+      const autoOptimizeThreshold = await number({
+        message: "Auto-optimize threshold (triggers optimization):",
+        default: config.realtime.autoOptimizeThreshold,
+        min: 1e3
+      });
+      const windowSize = await number({
+        message: "Sliding window size (entries):",
+        default: config.realtime.windowSize,
+        min: 100
+      });
+      const incremental = await confirm({
+        message: "Enable incremental optimization (faster delta processing)?",
+        default: config.realtime.incremental
+      });
+      config.realtime.tokenBudget = tokenBudget ?? config.realtime.tokenBudget;
+      config.realtime.autoOptimizeThreshold = autoOptimizeThreshold ?? config.realtime.autoOptimizeThreshold;
+      config.realtime.windowSize = windowSize ?? config.realtime.windowSize;
+      config.realtime.incremental = incremental;
+      console.log(neuralCyan("\n\u2713 Real-time settings updated"));
+      break;
+    }
+    case "ui": {
+      console.log(synapseViolet("\n\u{1F3A8} UI Preferences"));
+      console.log(dim("Customize terminal output\n"));
+      const colors = await confirm({
+        message: "Enable colored output?",
+        default: config.ui.colors
+      });
+      const verbose = await confirm({
+        message: "Enable verbose logging?",
+        default: config.ui.verbose
+      });
+      config.ui.colors = colors;
+      config.ui.verbose = verbose;
+      console.log(neuralCyan("\n\u2713 UI settings updated"));
+      break;
+    }
+  }
+  const updatedYAML = stringifyYAML2(config);
+  writeFileSync4(configPath, updatedYAML, "utf-8");
+  console.log(neuralCyan(`
+\u{1F4BE} Configuration saved to ${configPath}
+`));
+}
+async function optimizePreview(memory) {
+  console.log(neuralCyan("\n\u{1F50D} Optimization Preview\n"));
+  const inputFile = await input({
+    message: "Input file path (or press Enter to skip):",
+    default: ""
+  });
+  if (!inputFile) {
+    console.log(dim("\nNo file specified. Returning to menu.\n"));
+    return;
+  }
+  try {
+    const content = readFileSync5(resolve(process.cwd(), inputFile), "utf-8");
+    const tokensBefore = Math.ceil(content.length / 4);
+    console.log(synapseViolet("\n\u{1F4C4} File Preview:"));
+    console.log(dim(`  Length: ${content.length} characters`));
+    console.log(dim(`  Estimated tokens: ${tokensBefore.toLocaleString()}
+`));
+    const shouldOptimize = await confirm({
+      message: "Proceed with optimization?",
+      default: true
+    });
+    if (!shouldOptimize) {
+      console.log(dim("\nOptimization cancelled.\n"));
+      return;
+    }
+    console.log(neuralCyan("\n\u26A1 Optimizing...\n"));
+    const { optimizeCommand: optimizeCommand2 } = await Promise.resolve().then(() => (init_optimize(), optimize_exports));
+    const result = await optimizeCommand2({
+      inputFile,
+      memory,
+      dryRun: false,
+      verbose: false
+    });
+    console.log(neuralCyan(`
+\u2713 Optimization complete in ${result.durationMs}ms!`));
+    console.log(synapseViolet(`  Tokens: ${result.tokensBefore} \u2192 ${result.tokensAfter}`));
+    console.log(
+      brainPink(
+        `  Saved: ${result.tokensBefore - result.tokensAfter} tokens (${(result.reduction * 100).toFixed(1)}%)
+`
+      )
+    );
+    const saveOutput = await confirm({
+      message: "Save optimized output to file?",
+      default: false
+    });
+    if (saveOutput) {
+      const outputFile = await input({
+        message: "Output file path:",
+        default: inputFile.replace(/(\.[^.]+)$/, ".optimized$1")
+      });
+      writeFileSync4(resolve(process.cwd(), outputFile), result.output, "utf-8");
+      console.log(neuralCyan(`
+\u{1F4BE} Saved to ${outputFile}
+`));
+    }
+  } catch (error) {
+    console.error(errorRed("\n\u2717 Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+  }
+}
+async function showStatsDashboard(memory) {
+  console.log(neuralCyan("\n\u{1F4CA} Stats Dashboard\n"));
+  const view = await select({
+    message: "Select view:",
+    choices: [
+      { name: "\u{1F4C8} Optimization History", value: "history" },
+      { name: "\u26A1 Real-time Metrics", value: "realtime" },
+      { name: "\u{1F4BE} Memory Statistics", value: "memory" },
+      { name: "\u2190 Back to Main Menu", value: "back" }
+    ]
+  });
+  if (view === "back") return;
+  switch (view) {
+    case "history": {
+      const stats = await memory.getOptimizationStats();
+      const totalRuns = stats.length;
+      const totalTokensSaved = stats.reduce(
+        (sum, s) => sum + (s.tokens_before - s.tokens_after),
+        0
+      );
+      const avgReduction = totalRuns > 0 ? stats.reduce((sum, s) => {
+        return sum + (s.tokens_before > 0 ? (s.tokens_before - s.tokens_after) / s.tokens_before : 0);
+      }, 0) / totalRuns : 0;
+      console.log(brainPink("\n\u2501".repeat(60)));
+      console.log(neuralCyan("  \u{1F4C8} Optimization History"));
+      console.log(brainPink("\u2501".repeat(60)));
+      console.log(`  ${synapseViolet("Total runs:")}       ${totalRuns.toLocaleString()}`);
+      console.log(`  ${synapseViolet("Tokens saved:")}    ${totalTokensSaved.toLocaleString()}`);
+      console.log(`  ${synapseViolet("Avg reduction:")}   ${(avgReduction * 100).toFixed(1)}%`);
+      if (totalRuns > 0) {
+        console.log(`
+  ${dim("Recent optimizations:")}`);
+        const recent = stats.slice(0, 5);
+        for (const stat of recent) {
+          const date = new Date(stat.timestamp).toLocaleString();
+          const reduction = stat.tokens_before > 0 ? (stat.tokens_before - stat.tokens_after) / stat.tokens_before * 100 : 0;
+          console.log(`    ${dim(date)} - ${neuralCyan(`${reduction.toFixed(1)}%`)} reduction`);
+        }
+      }
+      console.log(brainPink(`${"\u2501".repeat(60)}
+`));
+      break;
+    }
+    case "realtime": {
+      const metrics = getMetrics();
+      const snapshot = metrics.getSnapshot();
+      console.log(brainPink("\n\u2501".repeat(60)));
+      console.log(neuralCyan("  \u26A1 Real-time Metrics"));
+      console.log(brainPink("\u2501".repeat(60)));
+      console.log(
+        `  ${synapseViolet("Total runs:")}      ${snapshot.optimization.totalRuns.toLocaleString()}`
+      );
+      console.log(
+        `  ${synapseViolet("Tokens saved:")}   ${snapshot.optimization.totalTokensSaved.toLocaleString()}`
+      );
+      console.log(
+        `  ${synapseViolet("Avg reduction:")}  ${(snapshot.optimization.averageReduction * 100).toFixed(1)}%`
+      );
+      console.log(
+        `  ${synapseViolet("P50 latency:")}   ${snapshot.optimization.p50Latency.toFixed(0)}ms`
+      );
+      console.log(
+        `  ${synapseViolet("P95 latency:")}   ${snapshot.optimization.p95Latency.toFixed(0)}ms`
+      );
+      console.log(
+        `  ${synapseViolet("P99 latency:")}   ${snapshot.optimization.p99Latency.toFixed(0)}ms`
+      );
+      console.log(
+        `
+  ${synapseViolet("Cache hit rate:")} ${(snapshot.cache.hitRate * 100).toFixed(1)}%`
+      );
+      console.log(
+        `  ${synapseViolet("Cache hits:")}     ${snapshot.cache.totalHits.toLocaleString()}`
+      );
+      console.log(
+        `  ${synapseViolet("Cache misses:")}   ${snapshot.cache.totalMisses.toLocaleString()}`
+      );
+      console.log(brainPink(`${"\u2501".repeat(60)}
+`));
+      break;
+    }
+    case "memory": {
+      const entries = await memory.query({});
+      const totalEntries = entries.length;
+      const totalSize = entries.reduce((sum, e) => sum + (e.content?.length || 0), 0);
+      console.log(brainPink("\n\u2501".repeat(60)));
+      console.log(neuralCyan("  \u{1F4BE} Memory Statistics"));
+      console.log(brainPink("\u2501".repeat(60)));
+      console.log(`  ${synapseViolet("Total entries:")}   ${totalEntries.toLocaleString()}`);
+      console.log(`  ${synapseViolet("Total size:")}      ${(totalSize / 1024).toFixed(1)} KB`);
+      console.log(
+        `  ${synapseViolet("Avg entry size:")}  ${totalEntries > 0 ? (totalSize / totalEntries).toFixed(0) : 0} bytes`
+      );
+      console.log(brainPink(`${"\u2501".repeat(60)}
+`));
+      break;
+    }
+  }
+}
+async function consolidateMemory(memory) {
+  console.log(neuralCyan("\n\u{1F9F9} Memory Consolidation\n"));
+  console.log(dim("This will:"));
+  console.log(dim("  \u2022 Remove decayed entries"));
+  console.log(dim("  \u2022 Merge duplicate entries"));
+  console.log(dim("  \u2022 VACUUM database to reclaim space\n"));
+  const shouldConsolidate = await confirm({
+    message: "Proceed with consolidation?",
+    default: true
+  });
+  if (!shouldConsolidate) {
+    console.log(dim("\nConsolidation cancelled.\n"));
+    return;
+  }
+  const { consolidateCommand: consolidateCommand2 } = await Promise.resolve().then(() => (init_consolidate(), consolidate_exports));
+  console.log(neuralCyan("\n\u26A1 Consolidating...\n"));
+  const result = await consolidateCommand2({ memory });
+  console.log(neuralCyan(`
+\u2713 Consolidation complete in ${result.durationMs}ms!`));
+  console.log(synapseViolet(`  Entries: ${result.entriesBefore} \u2192 ${result.entriesAfter}`));
+  console.log(
+    brainPink(
+      `  Removed: ${result.decayedRemoved} decayed, ${result.duplicatesRemoved} duplicates
+`
+    )
+  );
+}
+async function showQuickActions(memory, configPath) {
+  const action = await select({
+    message: "Quick Actions:",
+    choices: [
+      { name: "\u{1F504} Reset Statistics", value: "reset-stats" },
+      { name: "\u{1F4CB} Export Config (JSON)", value: "export-config" },
+      { name: "\u{1F9EA} Run Test Optimization", value: "test-optimize" },
+      { name: "\u2190 Back to Main Menu", value: "back" }
+    ]
+  });
+  if (action === "back") return;
+  switch (action) {
+    case "reset-stats": {
+      const confirmReset = await confirm({
+        message: "Are you sure you want to reset all statistics?",
+        default: false
+      });
+      if (confirmReset) {
+        await memory.clearOptimizationStats();
+        console.log(neuralCyan("\n\u2713 Statistics cleared\n"));
+      } else {
+        console.log(dim("\nReset cancelled.\n"));
+      }
+      break;
+    }
+    case "export-config": {
+      const configYAML = readFileSync5(configPath, "utf-8");
+      const config = parseYAML2(configYAML);
+      const json = JSON.stringify(config, null, 2);
+      console.log(synapseViolet("\n\u{1F4CB} Configuration (JSON):\n"));
+      console.log(json);
+      console.log();
+      const shouldSave = await confirm({
+        message: "Save to file?",
+        default: false
+      });
+      if (shouldSave) {
+        const outputPath = resolve(configPath.replace(/\.yaml$/, ".json"));
+        writeFileSync4(outputPath, json, "utf-8");
+        console.log(neuralCyan(`
+\u{1F4BE} Saved to ${outputPath}
+`));
+      }
+      break;
+    }
+    case "test-optimize": {
+      console.log(neuralCyan("\n\u{1F9EA} Running test optimization...\n"));
+      const testContent = `
+# Test Context
+
+This is a test context for optimization.
+It includes some sample content to demonstrate the optimization process.
+
+## Features
+- Token counting
+- Sparse coding
+- Decay application
+- State classification
+      `.trim();
+      const { optimizeCommand: optimizeCommand2 } = await Promise.resolve().then(() => (init_optimize(), optimize_exports));
+      const result = await optimizeCommand2({
+        input: testContent,
+        memory,
+        dryRun: true,
+        verbose: false
+      });
+      console.log(neuralCyan(`
+\u2713 Test optimization complete in ${result.durationMs}ms!`));
+      console.log(synapseViolet(`  Tokens: ${result.tokensBefore} \u2192 ${result.tokensAfter}`));
+      console.log(
+        brainPink(
+          `  Saved: ${result.tokensBefore - result.tokensAfter} tokens (${(result.reduction * 100).toFixed(1)}%)
+`
+        )
+      );
+      break;
+    }
+  }
+}
+async function interactiveCommand(options) {
+  const { memory, configPath } = options;
+  showWelcomeBanner();
+  let running = true;
+  while (running) {
+    try {
+      const choice = await showMainMenu();
+      switch (choice) {
+        case "configure":
+          await configureWizard(configPath);
+          break;
+        case "preview":
+          await optimizePreview(memory);
+          break;
+        case "stats":
+          await showStatsDashboard(memory);
+          break;
+        case "consolidate":
+          await consolidateMemory(memory);
+          break;
+        case "quick":
+          await showQuickActions(memory, configPath);
+          break;
+        case "exit":
+          running = false;
+          console.log(brainPink("\n\u{1F44B} Thanks for using Sparn!\n"));
+          break;
+      }
+    } catch (error) {
+      if (error.message === "User force closed the prompt") {
+        running = false;
+        console.log(brainPink("\n\u{1F44B} Thanks for using Sparn!\n"));
+      } else {
+        console.error(
+          errorRed("\n\u2717 Error:"),
+          error instanceof Error ? error.message : String(error)
+        );
+        console.log();
+      }
+    }
+  }
+  return {
+    success: true,
+    message: "Interactive session completed"
+  };
+}
+var init_interactive = __esm({
+  "src/cli/commands/interactive.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_metrics();
+    init_colors();
+  }
+});
+
 // src/cli/index.ts
 init_esm_shims();
 init_banner();
 import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname4, join as join4, resolve } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname4, join as join4, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { Command } from "commander";
 function getVersion2() {
   try {
-    const pkg = JSON.parse(readFileSync5(join4(process.cwd(), "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync6(join4(process.cwd(), "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     const __filename2 = fileURLToPath5(import.meta.url);
     const __dirname2 = dirname4(__filename2);
-    const pkg = JSON.parse(readFileSync5(join4(__dirname2, "../../package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync6(join4(__dirname2, "../../package.json"), "utf-8"));
     return pkg.version;
   }
 }
@@ -2087,23 +2592,23 @@ Typical Results:
   const spinner = createOptimizeSpinner2("\u{1F9E0} Initializing optimization...");
   try {
     spinner.start();
-    let input;
+    let input2;
     if (!options.input && process.stdin.isTTY === false) {
       spinner.text = "\u{1F4D6} Reading context from stdin...";
       const chunks = [];
       for await (const chunk of process.stdin) {
         chunks.push(chunk);
       }
-      input = Buffer.concat(chunks).toString("utf-8");
+      input2 = Buffer.concat(chunks).toString("utf-8");
     } else if (options.input) {
       spinner.text = `\u{1F4D6} Reading context from ${options.input}...`;
     }
     spinner.text = "\u{1F4BE} Loading memory database...";
-    const dbPath = resolve(process.cwd(), ".sparn/memory.db");
+    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
     spinner.text = "\u26A1 Applying neuroscience principles...";
     const result = await optimizeCommand2({
-      input,
+      input: input2,
       inputFile: options.input,
       outputFile: options.output,
       memory,
@@ -2163,7 +2668,7 @@ Tracked Metrics:
   try {
     if (spinner) spinner.start();
     if (spinner) spinner.text = "\u{1F4BE} Loading optimization history...";
-    const dbPath = resolve(process.cwd(), ".sparn/memory.db");
+    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
     let confirmReset = false;
     if (options.reset) {
@@ -2223,7 +2728,7 @@ The relay command passes the exit code from the wrapped command.
   const { relayCommand: relayCommand2 } = await Promise.resolve().then(() => (init_relay(), relay_exports));
   const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
   try {
-    const dbPath = resolve(process.cwd(), ".sparn/memory.db");
+    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
     const result = await relayCommand2({
       command,
@@ -2276,7 +2781,7 @@ Typical Results:
   try {
     spinner.start();
     spinner.text = "\u{1F4BE} Loading memory database...";
-    const dbPath = resolve(process.cwd(), ".sparn/memory.db");
+    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
     spinner.text = "\u{1F50D} Identifying decayed entries...";
     const result = await consolidateCommand2({ memory });
@@ -2324,7 +2829,7 @@ The config file is located at .sparn/config.yaml
   const { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
   try {
-    const configPath = resolve(process.cwd(), ".sparn/config.yaml");
+    const configPath = resolve2(process.cwd(), ".sparn/config.yaml");
     const result = await configCommand2({
       configPath,
       subcommand,
@@ -2379,13 +2884,13 @@ The daemon watches ~/.claude/projects/**/*.jsonl and automatically
 optimizes contexts when they exceed the configured threshold.
 `
 ).action(async (subcommand) => {
-  const { load: parseYAML2 } = await import("js-yaml");
+  const { load: parseYAML3 } = await import("js-yaml");
   const { createDaemonCommand: createDaemonCommand2 } = await Promise.resolve().then(() => (init_daemon_process(), daemon_process_exports));
   const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
   try {
-    const configPath = resolve(process.cwd(), ".sparn/config.yaml");
-    const configYAML = readFileSync5(configPath, "utf-8");
-    const config = parseYAML2(configYAML);
+    const configPath = resolve2(process.cwd(), ".sparn/config.yaml");
+    const configYAML = readFileSync6(configPath, "utf-8");
+    const config = parseYAML3(configYAML);
     const daemon = createDaemonCommand2();
     switch (subcommand) {
       case "start": {
@@ -2495,6 +3000,41 @@ and compress verbose tool results after execution.
     process.exit(1);
   }
 });
+program.command("interactive").alias("i").description("Launch interactive mode for configuration and exploration").addHelpText(
+  "after",
+  `
+Examples:
+  $ sparn interactive                   # Launch interactive mode
+  $ sparn i                             # Short alias
+
+Features:
+  \u2022 \u{1F4DD} Configuration Wizard - Guided prompts for all settings
+  \u2022 \u{1F50D} Optimization Preview - Test optimization with file preview
+  \u2022 \u{1F4CA} Stats Dashboard - Beautiful metrics display
+  \u2022 \u{1F9F9} Memory Consolidation - Interactive cleanup
+  \u2022 \u{1F680} Quick Actions - Common tasks and shortcuts
+
+The interactive mode provides a conversational interface for exploring
+and configuring Sparn without memorizing CLI flags.
+`
+).action(async () => {
+  const { createKVMemory: createKVMemory2 } = await Promise.resolve().then(() => (init_kv_memory(), kv_memory_exports));
+  const { interactiveCommand: interactiveCommand2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+  const { errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
+    const memory = await createKVMemory2(dbPath);
+    const configPath = resolve2(process.cwd(), ".sparn/config.yaml");
+    await interactiveCommand2({
+      memory,
+      configPath
+    });
+    await memory.close();
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
 program.on("option:version", () => {
   console.log(getBanner(VERSION2));
   process.exit(0);