aidp 0.34.0 → 0.39.3

data/lib/aidp/database.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+require "json"
+require "fileutils"
+
+module Aidp
+  # Database module for SQLite-based storage
+  # Provides connection management, schema migrations, and base repository functionality
+  module Database
+    class Error < StandardError; end
+    class MigrationError < Error; end
+    class ConnectionError < Error; end
+
+    # Thread-safe connection cache
+    @connections = {}
+    @mutex = Mutex.new
+
+    class << self
+      # Get or create a database connection for the given project directory
+      # Connections are cached per project_dir and are thread-safe
+      #
+      # @param project_dir [String] Project directory path
+      # @return [SQLite3::Database] Database connection
+      def connection(project_dir = Dir.pwd)
+        db_path = ConfigPaths.database_file(project_dir)
+
+        @mutex.synchronize do
+          # Return cached connection if valid
+          if @connections[db_path]&.closed? == false
+            return @connections[db_path]
+          end
+
+          # Ensure directory exists
+          FileUtils.mkdir_p(File.dirname(db_path))
+
+          # Create new connection with optimal settings
+          db = SQLite3::Database.new(db_path)
+          configure_connection(db)
+
+          @connections[db_path] = db
+          Aidp.log_debug("database", "connection_opened", path: db_path)
+          db
+        end
+      end
+
+      # Run pending migrations for the given project
+      #
+      # @param project_dir [String] Project directory path
+      # @return [Array<Integer>] List of applied migration versions
+      def migrate!(project_dir = Dir.pwd)
+        require_relative "database/migrations"
+        Migrations.run!(project_dir)
+      end
+
+      # Check if database exists and is initialized
+      #
+      # @param project_dir [String] Project directory path
+      # @return [Boolean] True if database exists
+      def exists?(project_dir = Dir.pwd)
+        File.exist?(ConfigPaths.database_file(project_dir))
+      end
+
+      # Get current schema version
+      #
+      # @param project_dir [String] Project directory path
+      # @return [Integer] Current schema version (0 if not initialized)
+      def schema_version(project_dir = Dir.pwd)
+        return 0 unless exists?(project_dir)
+
+        db = connection(project_dir)
+        result = db.get_first_value("SELECT MAX(version) FROM schema_migrations")
+        result || 0
+      rescue SQLite3::SQLException
+        # Table doesn't exist yet
+        0
+      end
+
+      # Close connection for a specific project
+      #
+      # @param project_dir [String] Project directory path
+      def close(project_dir = Dir.pwd)
+        db_path = ConfigPaths.database_file(project_dir)
+
+        @mutex.synchronize do
+          if @connections[db_path] && !@connections[db_path].closed?
+            @connections[db_path].close
+            Aidp.log_debug("database", "connection_closed", path: db_path)
+          end
+          @connections.delete(db_path)
+        end
+      end
+
+      # Close all open connections
+      def close_all
+        @mutex.synchronize do
+          @connections.each do |path, db|
+            db.close unless db.closed?
+            Aidp.log_debug("database", "connection_closed", path: path)
+          end
+          @connections.clear
+        end
+      end
+
+      # Execute a block within a transaction
+      #
+      # @param project_dir [String] Project directory path
+      # @yield [db] Block to execute within transaction
+      # @return [Object] Result of the block
+      def transaction(project_dir = Dir.pwd)
+        db = connection(project_dir)
+        db.transaction do
+          yield db
+        end
+      end
+
+      private
+
+      # Configure database connection with optimal settings
+      def configure_connection(db)
+        db.results_as_hash = true
+
+        # Enable WAL mode for better concurrency
+        db.execute("PRAGMA journal_mode = WAL")
+
+        # Enable foreign keys
+        db.execute("PRAGMA foreign_keys = ON")
+
+        # Optimize for performance
+        db.execute("PRAGMA synchronous = NORMAL")
+        db.execute("PRAGMA cache_size = -2000") # 2MB cache
+        db.execute("PRAGMA temp_store = MEMORY")
+
+        # Set busy timeout to 5 seconds
+        db.busy_timeout = 5000
+      end
+    end
+  end
+end

data/lib/aidp/debug_mixin.rb

@@ -15,11 +15,11 @@ module Aidp
     module ClassMethods
       # Class-level debug configuration
       def debug_enabled?
-        ENV["DEBUG"] && ENV["DEBUG"].to_i > 0
+        Aidp.debug_env_level.positive?
       end
 
       def debug_level
-        ENV["DEBUG"]&.to_i || DEBUG_OFF
+        Aidp.debug_env_level
       end
     end
 

data/lib/aidp/execute/checkpoint.rb

@@ -18,15 +18,19 @@ module Aidp
         @project_dir = project_dir
         @checkpoint_file = File.join(project_dir, ".aidp", "checkpoint.yml")
         @history_file = File.join(project_dir, ".aidp", "checkpoint_history.jsonl")
+        @run_loop_file = File.join(project_dir, ".aidp", "run_loop_started_at")
         ensure_checkpoint_directory
       end
 
       # Record a checkpoint during work loop iteration
       def record_checkpoint(step_name, iteration, metrics = {})
+        run_loop_started_at = read_run_loop_started_at || Time.now.iso8601
+        write_run_loop_started_at(run_loop_started_at) if iteration == 1
         checkpoint_data = {
           step_name: step_name,
           iteration: iteration,
           timestamp: Time.now.iso8601,
+          run_loop_started_at: run_loop_started_at,
           metrics: collect_metrics.merge(metrics),
           status: determine_status(metrics)
         }
@@ -40,6 +44,7 @@ module Aidp
       # Get the latest checkpoint data
       def latest_checkpoint
         return nil unless File.exist?(@checkpoint_file)
+
         YAML.safe_load_file(@checkpoint_file, permitted_classes: [Date, Time, Symbol], aliases: true)
       end
 
@@ -300,6 +305,27 @@ module Aidp
           f.puts(data.to_json)
         end
       end
+
+      def read_run_loop_started_at
+        return nil unless File.exist?(@run_loop_file)
+
+        File.read(@run_loop_file).strip
+      rescue => e
+        log_rescue(e,
+          component: "checkpoint",
+          action: "read_run_loop_started_at",
+          fallback: nil)
+        nil
+      end
+
+      def write_run_loop_started_at(timestamp)
+        File.write(@run_loop_file, timestamp)
+      rescue => e
+        log_rescue(e,
+          component: "checkpoint",
+          action: "write_run_loop_started_at",
+          fallback: nil)
+      end
     end
   end
 end

data/lib/aidp/execute/checkpoint_display.rb

@@ -43,6 +43,22 @@ module Aidp
         current = summary[:current]
         @prompt.say("Step: #{@pastel.cyan(current[:step_name])}")
         @prompt.say("Iteration: #{current[:iteration]}")
+        if current[:run_loop_started_at]
+          started = begin
+            Time.parse(current[:run_loop_started_at])
+          rescue
+            current[:run_loop_started_at]
+          end
+          @prompt.say("Run Loop Started: #{@pastel.blue(started.is_a?(Time) ? started.strftime("%Y-%m-%d %H:%M:%S") : started)}")
+        end
+        if current[:timestamp]
+          ts = begin
+            Time.parse(current[:timestamp])
+          rescue
+            current[:timestamp]
+          end
+          @prompt.say("Last Run: #{@pastel.magenta(ts.is_a?(Time) ? ts.strftime("%Y-%m-%d %H:%M:%S") : ts)}")
+        end
         @prompt.say("Status: #{format_status(current[:status])}")
         @prompt.say("")
 

data/lib/aidp/execute/prompt_evaluator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../harness/ai_decision_engine"
+require_relative "../prompts/prompt_template_manager"
 
 module Aidp
   module Execute
@@ -15,6 +16,11 @@ module Aidp
     # - Whether the agent has sufficient context
     # - If there are blockers preventing progress
     #
+    # Prompts can be customized via YAML templates at:
+    # - Project level: .aidp/prompts/prompt_evaluator/<name>.yml
+    # - User level: ~/.aidp/prompts/prompt_evaluator/<name>.yml
+    # - Built-in: lib/aidp/prompts/defaults/prompt_evaluator/<name>.yml
+    #
     # @example
     #   evaluator = PromptEvaluator.new(config)
     #   result = evaluator.evaluate(
@@ -26,6 +32,12 @@ module Aidp
     #   # => { effective: false, issues: [...], suggestions: [...] }
     #
     class PromptEvaluator
+      # Template paths for dynamic prompts
+      TEMPLATE_PATHS = {
+        evaluation: "prompt_evaluator/evaluation",
+        improvement: "prompt_evaluator/improvement"
+      }.freeze
+
       # Threshold for triggering evaluation
       EVALUATION_ITERATION_THRESHOLD = 10
 
@@ -33,10 +45,12 @@ module Aidp
       EVALUATION_INTERVAL = 5
 
       # Expose for testability
-      attr_reader :ai_decision_engine
+      attr_reader :ai_decision_engine, :prompt_template_manager
 
-      def initialize(config, ai_decision_engine: nil)
+      def initialize(config, ai_decision_engine: nil, prompt_template_manager: nil, project_dir: Dir.pwd)
         @config = config
+        @project_dir = project_dir
+        @prompt_template_manager = prompt_template_manager || Prompts::PromptTemplateManager.new(project_dir: project_dir)
         @ai_decision_engine = ai_decision_engine || safely_build_ai_decision_engine
       end
 
@@ -232,66 +246,25 @@ module Aidp
       private
 
       def build_evaluation_prompt(prompt_content:, iteration_count:, task_summary:, recent_failures:)
-        <<~PROMPT
-          You are evaluating the effectiveness of a work loop prompt that has been running for #{iteration_count} iterations without completion.
-
-          ## Current Prompt Content
-          #{truncate_content(prompt_content, 8000)}
-
-          ## Task Summary
-          #{format_task_summary(task_summary)}
-
-          ## Recent Check Results
-          #{format_failures(recent_failures)}
-
-          ## Evaluation Criteria
-
-          Analyze why this prompt may not be leading to completion:
-
-          1. **Clarity of Goals**: Are the implementation requirements clearly defined?
-          2. **Task Breakdown**: Does the prompt guide proper task decomposition?
-          3. **Completion Criteria**: Are the completion criteria specific and achievable?
-          4. **Context Sufficiency**: Does the agent have enough context to proceed?
-          5. **Blockers**: Are there technical blockers or missing information?
-          6. **Scope**: Is the scope realistic for an AI agent to complete?
-
-          ## Your Assessment
-
-          Provide:
-          - Whether this prompt is likely effective (true/false)
-          - Specific issues with the current prompt
-          - Actionable suggestions for improvement
-          - Likely blockers preventing progress
-          - Prioritized recommended actions
-          - Your confidence in this assessment (0.0-1.0)
+        variables = {
+          iteration_count: iteration_count.to_s,
+          prompt_content: truncate_content(prompt_content, 8000),
+          task_summary: format_task_summary(task_summary),
+          recent_failures: format_failures(recent_failures)
+        }
 
-          Be specific and actionable. Focus on what can be changed to achieve completion.
-        PROMPT
+        @prompt_template_manager.render(TEMPLATE_PATHS[:evaluation], **variables)
       end
 
       def build_improvement_prompt(evaluation_result, original_template)
-        <<~PROMPT
-          Based on the following prompt evaluation, suggest improvements to the template.
-
-          ## Evaluation Results
-          - Effective: #{evaluation_result[:effective]}
-          - Issues: #{(evaluation_result[:issues] || []).join(", ")}
-          - Suggestions: #{(evaluation_result[:suggestions] || []).join(", ")}
-
-          ## Original Template
-          #{truncate_content(original_template, 4000)}
-
-          ## Your Task
-
-          Suggest specific improvements to make the template more effective:
-          1. Identify sections that need improvement
-          2. Propose new sections if needed
-          3. Focus especially on completion criteria clarity
-          4. Ensure task breakdown instructions are explicit
-          5. Add guidance for common failure modes
+        variables = {
+          effective: evaluation_result[:effective].to_s,
+          issues: (evaluation_result[:issues] || []).join(", "),
+          suggestions: (evaluation_result[:suggestions] || []).join(", "),
+          original_template: truncate_content(original_template, 4000)
+        }
 
-          Be specific - provide actual text that could replace or supplement the template.
-        PROMPT
+        @prompt_template_manager.render(TEMPLATE_PATHS[:improvement], **variables)
       end
 
       def format_task_summary(task_summary)