Migrate analysis cache from SQLite to H2 for virtual thread compatibility

SQLite JDBC uses JNI which pins virtual threads to platform threads,
killing parallelism. H2 is pure Java with MVCC concurrency — no JNI,
fully virtual-thread friendly. Also adds minified file detection
(skip detectors for *.min.js etc.) and Neo4j shutdown hook hardening.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: aksOps

pom.xml

@@ -128,11 +128,10 @@
             <version>4.13.2</version>
         </dependency>
 
-        <!-- SQLite JDBC for incremental analysis cache -->
+        <!-- H2 Database for incremental analysis cache (pure Java — no JNI, virtual-thread friendly) -->
         <dependency>
-            <groupId>org.xerial</groupId>
-            <artifactId>sqlite-jdbc</artifactId>
-            <version>3.49.1.0</version>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
         </dependency>
 
         <!-- Testing -->

src/main/java/io/github/randomcodespace/iq/analyzer/Analyzer.java

@@ -11,6 +11,7 @@
 import io.github.randomcodespace.iq.detector.DetectorUtils;
 import io.github.randomcodespace.iq.grammar.AntlrParserFactory;
 import io.github.randomcodespace.iq.model.CodeNode;
+import io.github.randomcodespace.iq.model.NodeKind;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
@@ -302,6 +303,32 @@ private AnalysisResult runWithCache(Path root, Integer parallelism, AnalysisCach
     /**
      * Analyze a single file: read content, parse if structured, run matching detectors.
      */
+    /**
+     * Check whether a file is minified (e.g. *.min.js, *.bundle.js) and large
+     * enough that running detectors would be wasteful.
+     * <p>
+     * Heuristic: filename ends with .min.js or .bundle.js, file is &gt; 10 KB,
+     * and average line length exceeds 500 characters.
+     */
+    private boolean isMinified(DiscoveredFile file, String content) {
+        String name = file.path().getFileName().toString();
+        if (!(name.endsWith(".min.js") || name.endsWith(".bundle.js")
+                || name.endsWith(".min.css") || name.endsWith(".min.mjs"))) {
+            return false;
+        }
+        if (file.sizeBytes() <= 10_240) {
+            return false;
+        }
+        // Average line length check
+        String[] lines = content.split("\n", -1);
+        if (lines.length == 0) return false;
+        long totalChars = 0;
+        for (String line : lines) {
+            totalChars += line.length();
+        }
+        return (totalChars / lines.length) > 500;
+    }
+
     DetectorResult analyzeFile(DiscoveredFile file, Path repoPath) {
         Instant fileStart = Instant.now();
         Path absPath = repoPath.resolve(file.path());
@@ -316,6 +343,20 @@ DetectorResult analyzeFile(DiscoveredFile file, Path repoPath) {
             return DetectorResult.empty();
         }
 
+        // Minified file detection: create a node with minified=true but skip detectors
+        if (isMinified(file, content)) {
+            log.debug("Skipping detectors for minified file: {}", file.path());
+            String moduleName = DetectorUtils.deriveModuleName(file.path().toString(), file.language());
+            CodeNode node = new CodeNode(
+                    "file:" + file.path() + ":module:" + (moduleName != null ? moduleName : file.path().getFileName().toString()),
+                    NodeKind.MODULE,
+                    file.path().getFileName().toString());
+            node.setFilePath(file.path().toString());
+            node.setModule(moduleName);
+            node.setProperties(new java.util.LinkedHashMap<>(Map.of("minified", true)));
+            return DetectorResult.of(List.of(node), List.of());
+        }
+
         // Parse structured data if applicable
         Object parsedData = null;
         if (STRUCTURED_LANGUAGES.contains(file.language())) {

src/main/java/io/github/randomcodespace/iq/api/GraphController.java

@@ -57,8 +57,10 @@ public Map<String, Object> getDetailedStats(
             @RequestParam(defaultValue = "all") String category) {
         Path root = Path.of(config.getRootPath()).toAbsolutePath().normalize();
         Path cachePath = root.resolve(config.getCacheDir()).resolve("analysis-cache.db");
+        // H2 stores data in analysis-cache.mv.db — check for that file on disk
+        Path h2File = root.resolve(config.getCacheDir()).resolve("analysis-cache.mv.db");
 
-        if (!Files.exists(cachePath)) {
+        if (!Files.exists(h2File)) {
             throw new ResponseStatusException(HttpStatus.NOT_FOUND,
                     "No analysis cache found. Run analyze first.");
         }

src/main/java/io/github/randomcodespace/iq/cache/AnalysisCache.java

@@ -26,47 +26,46 @@
 import java.util.UUID;
 
 /**
- * SQLite-backed cache for incremental analysis results.
+ * H2-backed cache for incremental analysis results.
  * <p>
  * Stores per-file parse results (nodes and edges) keyed by content hash,
  * enabling fast incremental re-analysis when only a subset of files change.
  * <p>
- * Uses plain JDBC with SQLite -- not Neo4j -- as the cache is a flat
- * lookup table, not a graph.
+ * Uses H2 in embedded mode — pure Java, no JNI, MVCC concurrency,
+ * fully compatible with virtual threads.
  */
 public class AnalysisCache implements Closeable {
 
     private static final Logger log = LoggerFactory.getLogger(AnalysisCache.class);
 
     private static final String SCHEMA_SQL = """
             CREATE TABLE IF NOT EXISTS files (
-                content_hash TEXT PRIMARY KEY,
-                path TEXT NOT NULL,
-                language TEXT NOT NULL,
-                parsed_at TEXT NOT NULL
+                content_hash VARCHAR PRIMARY KEY,
+                path VARCHAR NOT NULL,
+                language VARCHAR NOT NULL,
+                parsed_at VARCHAR NOT NULL
             );
 
             CREATE TABLE IF NOT EXISTS nodes (
-                id TEXT PRIMARY KEY,
-                content_hash TEXT NOT NULL,
-                kind TEXT NOT NULL,
-                data TEXT NOT NULL,
+                id VARCHAR PRIMARY KEY,
+                content_hash VARCHAR NOT NULL,
+                kind VARCHAR NOT NULL,
+                data VARCHAR NOT NULL,
                 FOREIGN KEY (content_hash) REFERENCES files(content_hash)
             );
 
             CREATE TABLE IF NOT EXISTS edges (
-                source TEXT NOT NULL,
-                target TEXT NOT NULL,
-                content_hash TEXT NOT NULL,
-                kind TEXT NOT NULL,
-                data TEXT NOT NULL,
-                FOREIGN KEY (content_hash) REFERENCES files(content_hash)
+                source VARCHAR NOT NULL,
+                target VARCHAR NOT NULL,
+                content_hash VARCHAR NOT NULL,
+                kind VARCHAR NOT NULL,
+                data VARCHAR NOT NULL
             );
 
             CREATE TABLE IF NOT EXISTS analysis_runs (
-                run_id TEXT PRIMARY KEY,
-                commit_sha TEXT,
-                timestamp TEXT NOT NULL,
+                run_id VARCHAR PRIMARY KEY,
+                commit_sha VARCHAR,
+                timestamp VARCHAR NOT NULL,
                 file_count INTEGER NOT NULL
             );
 
@@ -82,30 +81,29 @@ CREATE TABLE IF NOT EXISTS analysis_runs (
 
     /**
      * Open or create an analysis cache at the given path.
+     * <p>
+     * The path should point to the desired database file location.
+     * H2 will append {@code .mv.db} to the actual file on disk.
      *
-     * @param dbPath path to the SQLite database file
+     * @param dbPath path to the H2 database file (without extension)
      */
     public AnalysisCache(Path dbPath) {
         this.dbPath = dbPath;
         try {
             Files.createDirectories(dbPath.getParent());
-            this.conn = DriverManager.getConnection("jdbc:sqlite:" + dbPath);
-            // Configure pragmas using separate statements, each closed before the next
-            executePragma("PRAGMA journal_mode=WAL");
-            executePragma("PRAGMA busy_timeout=5000");
-            executePragma("PRAGMA foreign_keys=ON");
+            // Strip .db extension if present — H2 appends its own .mv.db
+            String dbFile = dbPath.toString();
+            if (dbFile.endsWith(".db")) {
+                dbFile = dbFile.substring(0, dbFile.length() - 3);
+            }
+            this.conn = DriverManager.getConnection(
+                    "jdbc:h2:file:" + dbFile + ";AUTO_SERVER=FALSE;MODE=MySQL");
             initDb();
         } catch (Exception e) {
             throw new RuntimeException("Failed to open analysis cache at " + dbPath, e);
         }
     }
 
-    private void executePragma(String pragma) throws SQLException {
-        try (var stmt = conn.createStatement()) {
-            stmt.execute(pragma);
-        }
-    }
-
     private void initDb() throws SQLException {
         for (String sql : SCHEMA_SQL.split(";")) {
             String trimmed = sql.trim();
@@ -158,14 +156,13 @@ public boolean isCached(String contentHash) {
      */
     public void storeResults(String contentHash, String filePath, String language,
                              List<CodeNode> nodes, List<CodeEdge> edges) {
-        synchronized (conn) {
         try {
             conn.setAutoCommit(false);
             String now = Instant.now().toString();
 
-            // Upsert file record
+            // Upsert file record (H2 MySQL mode supports INSERT ... ON DUPLICATE KEY UPDATE)
             try (var stmt = conn.prepareStatement(
-                    "INSERT OR REPLACE INTO files (content_hash, path, language, parsed_at) VALUES (?, ?, ?, ?)")) {
+                    "MERGE INTO files (content_hash, path, language, parsed_at) KEY (content_hash) VALUES (?, ?, ?, ?)")) {
                 stmt.setString(1, contentHash);
                 stmt.setString(2, filePath);
                 stmt.setString(3, language);
@@ -185,7 +182,7 @@ public void storeResults(String contentHash, String filePath, String language,
 
             // Insert nodes
             try (var stmt = conn.prepareStatement(
-                    "INSERT OR IGNORE INTO nodes (id, content_hash, kind, data) VALUES (?, ?, ?, ?)")) {
+                    "INSERT INTO nodes (id, content_hash, kind, data) VALUES (?, ?, ?, ?)")) {
                 for (CodeNode node : nodes) {
                     stmt.setString(1, node.getId());
                     stmt.setString(2, contentHash);
@@ -223,7 +220,6 @@ public void storeResults(String contentHash, String filePath, String language,
             } catch (SQLException ignored) {
             }
         }
-        } // synchronized
     }
 
     // --- Load cached results ---

src/main/java/io/github/randomcodespace/iq/cli/StatsCommand.java

@@ -27,7 +27,7 @@
 
 /**
  * Show rich categorized statistics from an already-analyzed graph.
- * Reads from the SQLite analysis cache -- no re-scan.
+ * Reads from the H2 analysis cache -- no re-scan.
  */
 @Component
 @Command(name = "stats", mixinStandardHelpOptions = true,
@@ -80,8 +80,10 @@ public Integer call() {
 
         Path root = path.toAbsolutePath().normalize();
         Path cachePath = root.resolve(config.getCacheDir()).resolve("analysis-cache.db");
+        // H2 stores data in analysis-cache.mv.db — check for that file on disk
+        Path h2File = root.resolve(config.getCacheDir()).resolve("analysis-cache.mv.db");
 
-        if (!Files.exists(cachePath)) {
+        if (!Files.exists(h2File)) {
             CliOutput.warn("No analysis cache found at " + cachePath);
             CliOutput.info("Run 'code-iq analyze' first to scan the codebase.");
             return 1;

src/main/java/io/github/randomcodespace/iq/config/Neo4jConfig.java

@@ -28,7 +28,16 @@ public class Neo4jConfig {
     @Bean(destroyMethod = "shutdown")
     DatabaseManagementService databaseManagementService(
             @Value("${codeiq.graph.path:.osscodeiq/graph.db}") String dbPath) {
-        return new DatabaseManagementServiceBuilder(Path.of(dbPath)).build();
+        DatabaseManagementService dbms = new DatabaseManagementServiceBuilder(Path.of(dbPath)).build();
+        // Ensure clean shutdown even if Spring context is not closed gracefully
+        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+            try {
+                dbms.shutdown();
+            } catch (Exception ignored) {
+                // Already shut down by Spring's destroyMethod, or JVM is exiting
+            }
+        }, "neo4j-shutdown-hook"));
+        return dbms;
     }
 
     @Bean

src/main/java/io/github/randomcodespace/iq/mcp/McpTools.java

@@ -65,8 +65,10 @@ public String getDetailedStats(
         try {
             java.nio.file.Path root = java.nio.file.Path.of(config.getRootPath()).toAbsolutePath().normalize();
             java.nio.file.Path cachePath = root.resolve(config.getCacheDir()).resolve("analysis-cache.db");
+            // H2 stores data in analysis-cache.mv.db — check for that file on disk
+            java.nio.file.Path h2File = root.resolve(config.getCacheDir()).resolve("analysis-cache.mv.db");
 
-            if (!java.nio.file.Files.exists(cachePath)) {
+            if (!java.nio.file.Files.exists(h2File)) {
                 return toJson(Map.of("error", "No analysis cache found. Run analyze first."));
             }