Repeatable

docs/query-optimization-review-prompt.md

@@ -5,7 +5,7 @@ This prompt is designed to be used with AI coding agents (like Antigravity, GitH
 ---
 
 ## 🚀 AI Review Prompt
-Carry out a review of the diff between the current branch and the main branch, focusing on the optimizations made by the `QueryOptimizer` tool.
+Carry out a review of the diff of the current, focusing on the optimizations made by the `QueryOptimizer` tool.
 
 **Context:**
 I have executed an automated `QueryOptimizer` on my Spring Boot / JPA project. The tool has performed two optimizations:

pom.xml

@@ -15,6 +15,7 @@
         <slf4j.version>2.0.13</slf4j.version>
         <javaparser.version>3.26.2</javaparser.version>
         <maven.compiler.plugin.version>3.13.0</maven.compiler.plugin.version>
+        <antikythera.version>0.1.3.2</antikythera.version>
     </properties>
 
     <repositories>
@@ -28,15 +29,14 @@
         <dependency>
             <groupId>sa.com.cloudsolutions</groupId>
             <artifactId>antikythera</artifactId>
-            <version>0.1.3.1</version>
+            <version>${antikythera.version}</version>
             <exclusions>
                 <exclusion>
                     <groupId>ch.qos.logback</groupId>
                     <artifactId>logback-classic</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>
-
         <!-- Explicit dependencies for IDE resolution -->
         <dependency>
             <groupId>org.slf4j</groupId>
@@ -65,7 +65,7 @@
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
             <version>5.11.0</version>
-            <scope>test</scope>
+            <!-- Evaluator in antikythera requires Mockito at runtime for field setup -->
         </dependency>
         <dependency>
             <groupId>com.github.jsqlparser</groupId>
@@ -89,7 +89,7 @@
         <dependency>
             <groupId>com.raditha</groupId>
             <artifactId>hql-parser</artifactId>
-            <version>0.0.15</version>
+            <version>0.0.16</version>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -136,12 +136,17 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>2.17.0</version>
+            <version>2.17.2</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
-            <version>2.17.0</version>
+            <version>2.17.2</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.dataformat</groupId>
+            <artifactId>jackson-dataformat-yaml</artifactId>
+            <version>2.17.2</version>
         </dependency>
     </dependencies>
 

src/main/java/sa/com/cloudsolutions/antikythera/examples/CheckpointManager.java

@@ -0,0 +1,278 @@
+package sa.com.cloudsolutions.antikythera.examples;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.time.Instant;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * Manages checkpoint/resume functionality for QueryOptimizer.
+ * Saves state to a JSON file after each successful repository analysis,
+ * allowing the optimizer to resume from where it left off if interrupted.
+ *
+ * <p>The checkpoint file is automatically deleted on successful completion
+ * of a full run.</p>
+ *
+ * <p>Usage:</p>
+ * <pre>
+ * CheckpointManager checkpoint = new CheckpointManager();
+ * checkpoint.load(); // Load existing checkpoint if present
+ *
+ * // Before processing each repository:
+ * if (checkpoint.isProcessed(repoName)) {
+ *     // Skip - already processed in previous run
+ *     continue;
+ * }
+ *
+ * // After successful processing:
+ * checkpoint.markProcessed(repoName);
+ * checkpoint.save();
+ *
+ * // On successful completion of all repositories:
+ * checkpoint.clear();
+ * </pre>
+ */
+public class CheckpointManager {
+    private static final Logger logger = LoggerFactory.getLogger(CheckpointManager.class);
+    private static final String DEFAULT_CHECKPOINT_FILE = ".query-optimizer-checkpoint.json";
+
+    private final File checkpointFile;
+    private final ObjectMapper objectMapper;
+    private Checkpoint checkpoint;
+    private boolean loaded = false;
+
+    /**
+     * Creates a CheckpointManager using the default checkpoint file location.
+     */
+    public CheckpointManager() {
+        this(new File(DEFAULT_CHECKPOINT_FILE));
+    }
+
+    /**
+     * Creates a CheckpointManager with a custom checkpoint file location.
+     *
+     * @param checkpointFile the file to use for checkpoint storage
+     */
+    public CheckpointManager(File checkpointFile) {
+        this.checkpointFile = checkpointFile;
+        this.objectMapper = new ObjectMapper();
+        this.objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
+        this.checkpoint = new Checkpoint();
+    }
+
+    /**
+     * Loads an existing checkpoint from disk if present.
+     * If no checkpoint exists or loading fails, starts with a fresh checkpoint.
+     * This method is idempotent - calling it multiple times returns the same result.
+     *
+     * @return true if a checkpoint was loaded, false if starting fresh
+     */
+    public boolean load() {
+        // Return cached result if already loaded
+        if (loaded) {
+            return checkpoint.processedRepositories != null && !checkpoint.processedRepositories.isEmpty();
+        }
+
+        if (!checkpointFile.exists()) {
+            logger.debug("No checkpoint file found, starting fresh");
+            checkpoint = new Checkpoint();
+            checkpoint.sessionId = UUID.randomUUID().toString();
+            checkpoint.startTime = Instant.now().toString();
+            loaded = true;
+            return false;
+        }
+
+        try {
+            checkpoint = objectMapper.readValue(checkpointFile, Checkpoint.class);
+            logger.info("Loaded checkpoint from {} - {} repositories already processed",
+                    checkpointFile.getName(), checkpoint.processedRepositories.size());
+            loaded = true;
+            return true;
+        } catch (IOException e) {
+            logger.warn("Failed to load checkpoint file: {}. Starting fresh.", e.getMessage());
+            checkpoint = new Checkpoint();
+            checkpoint.sessionId = UUID.randomUUID().toString();
+            checkpoint.startTime = Instant.now().toString();
+            loaded = true;
+            return false;
+        }
+    }
+
+    /**
+     * Saves the current checkpoint state to disk.
+     * Call this after each successful repository analysis.
+     */
+    public void save() {
+        checkpoint.lastUpdate = Instant.now().toString();
+        try {
+            objectMapper.writeValue(checkpointFile, checkpoint);
+            logger.debug("Checkpoint saved: {} repositories processed",
+                    checkpoint.processedRepositories.size());
+        } catch (IOException e) {
+            logger.error("Failed to save checkpoint: {}", e.getMessage());
+        }
+    }
+
+    /**
+     * Clears the checkpoint file. Call this on successful completion of a full run.
+     */
+    public void clear() {
+        if (checkpointFile.exists()) {
+            if (checkpointFile.delete()) {
+                logger.info("Checkpoint cleared - run completed successfully");
+            } else {
+                logger.warn("Failed to delete checkpoint file: {}", checkpointFile.getName());
+            }
+        }
+        checkpoint = new Checkpoint();
+        loaded = false;
+    }
+
+    /**
+     * Checks if a repository has already been processed in this session.
+     *
+     * @param fullyQualifiedName the fully qualified repository class name
+     * @return true if already processed
+     */
+    public boolean isProcessed(String fullyQualifiedName) {
+        return checkpoint.processedRepositories.contains(fullyQualifiedName);
+    }
+
+    /**
+     * Marks a repository as successfully processed.
+     *
+     * @param fullyQualifiedName the fully qualified repository class name
+     */
+    public void markProcessed(String fullyQualifiedName) {
+        checkpoint.processedRepositories.add(fullyQualifiedName);
+    }
+
+    /**
+     * Gets the set of already processed repositories.
+     *
+     * @return unmodifiable set of processed repository names
+     */
+    public Set<String> getProcessedRepositories() {
+        return Set.copyOf(checkpoint.processedRepositories);
+    }
+
+    /**
+     * Gets the number of repositories processed so far.
+     *
+     * @return count of processed repositories
+     */
+    public int getProcessedCount() {
+        return checkpoint.processedRepositories.size();
+    }
+
+    /**
+     * Stores accumulated index suggestions for resume capability.
+     *
+     * @param singleColumnIndexes single-column index suggestions (table|column format)
+     * @param multiColumnIndexes multi-column index suggestions (table|col1,col2 format)
+     */
+    public void setIndexSuggestions(LinkedHashSet<String> singleColumnIndexes,
+                                     LinkedHashSet<String> multiColumnIndexes) {
+        checkpoint.suggestedNewIndexes = new LinkedHashSet<>(singleColumnIndexes);
+        checkpoint.suggestedMultiColumnIndexes = new LinkedHashSet<>(multiColumnIndexes);
+    }
+
+    /**
+     * Gets the accumulated single-column index suggestions.
+     *
+     * @return set of index suggestions in table|column format
+     */
+    public LinkedHashSet<String> getSuggestedNewIndexes() {
+        return checkpoint.suggestedNewIndexes != null
+                ? new LinkedHashSet<>(checkpoint.suggestedNewIndexes)
+                : new LinkedHashSet<>();
+    }
+
+    /**
+     * Gets the accumulated multi-column index suggestions.
+     *
+     * @return set of index suggestions in table|col1,col2 format
+     */
+    public LinkedHashSet<String> getSuggestedMultiColumnIndexes() {
+        return checkpoint.suggestedMultiColumnIndexes != null
+                ? new LinkedHashSet<>(checkpoint.suggestedMultiColumnIndexes)
+                : new LinkedHashSet<>();
+    }
+
+    /**
+     * Stores the set of modified files for resume capability.
+     *
+     * @param modifiedFiles set of fully qualified class names that were modified
+     */
+    public void setModifiedFiles(Set<String> modifiedFiles) {
+        checkpoint.modifiedFiles = new HashSet<>(modifiedFiles);
+    }
+
+    /**
+     * Gets the set of files that were modified in this session.
+     *
+     * @return set of modified file class names
+     */
+    public Set<String> getModifiedFiles() {
+        return checkpoint.modifiedFiles != null
+                ? new HashSet<>(checkpoint.modifiedFiles)
+                : new HashSet<>();
+    }
+
+    /**
+     * Checks if there's an existing checkpoint to resume from.
+     *
+     * @return true if a checkpoint file exists
+     */
+    public boolean hasCheckpoint() {
+        return checkpointFile.exists();
+    }
+
+    /**
+     * Gets the session ID for the current checkpoint.
+     *
+     * @return the session UUID string
+     */
+    public String getSessionId() {
+        return checkpoint.sessionId;
+    }
+
+    /**
+     * Gets the checkpoint file location.
+     *
+     * @return the checkpoint file
+     */
+    public File getCheckpointFile() {
+        return checkpointFile;
+    }
+
+    /**
+     * Data class representing the checkpoint state.
+     * Uses Jackson for JSON serialization.
+     */
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public static class Checkpoint {
+        private String sessionId;
+        private String startTime;
+        private String lastUpdate;
+        public Set<String> processedRepositories = new HashSet<>();
+        public Set<String> suggestedNewIndexes = new LinkedHashSet<>();
+        public Set<String> suggestedMultiColumnIndexes = new LinkedHashSet<>();
+        public Set<String> modifiedFiles = new HashSet<>();
+
+        // Default constructor for Jackson
+        public Checkpoint() {
+            this.sessionId = UUID.randomUUID().toString();
+            this.startTime = Instant.now().toString();
+        }
+    }
+}