aidp 0.34.1 → 0.39.3

data/lib/aidp/database/repositories/progress_repository.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for progress table
+      # Replaces progress/execute.yml and progress/analyze.yml
+      class ProgressRepository < Repository
+        VALID_MODES = %w[execute analyze].freeze
+
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "progress")
+        end
+
+        # Get progress for a mode
+        #
+        # @param mode [String, Symbol] Mode (execute or analyze)
+        # @return [Hash] Progress data
+        def get(mode)
+          mode_str = mode.to_s
+          row = query_one(
+            "SELECT * FROM progress WHERE project_dir = ? AND mode = ?",
+            [project_dir, mode_str]
+          )
+
+          return empty_progress(mode_str) unless row
+
+          deserialize_progress(row)
+        end
+
+        # Get completed steps
+        #
+        # @param mode [String, Symbol] Mode
+        # @return [Array<String>] Completed step names
+        def completed_steps(mode)
+          progress = get(mode)
+          progress[:steps_completed] || []
+        end
+
+        # Get current step
+        #
+        # @param mode [String, Symbol] Mode
+        # @return [String, nil] Current step name
+        def current_step(mode)
+          progress = get(mode)
+          progress[:current_step]
+        end
+
+        # Check if step is completed
+        #
+        # @param mode [String, Symbol] Mode
+        # @param step_name [String] Step name
+        # @return [Boolean]
+        def step_completed?(mode, step_name)
+          completed_steps(mode).include?(step_name)
+        end
+
+        # Mark step as completed
+        #
+        # @param mode [String, Symbol] Mode
+        # @param step_name [String] Step name
+        def mark_step_completed(mode, step_name)
+          mode_str = mode.to_s
+          progress = get(mode)
+
+          steps = progress[:steps_completed] || []
+          steps << step_name unless steps.include?(step_name)
+
+          now = current_timestamp
+          started_at = progress[:started_at] || now
+
+          upsert_progress(
+            mode: mode_str,
+            current_step: nil,
+            steps_completed: steps,
+            started_at: started_at,
+            updated_at: now
+          )
+
+          Aidp.log_debug("progress_repository", "step_completed",
+            mode: mode_str, step: step_name)
+        end
+
+        # Mark step as in progress
+        #
+        # @param mode [String, Symbol] Mode
+        # @param step_name [String] Step name
+        def mark_step_in_progress(mode, step_name)
+          mode_str = mode.to_s
+          progress = get(mode)
+
+          now = current_timestamp
+          started_at = progress[:started_at] || now
+
+          upsert_progress(
+            mode: mode_str,
+            current_step: step_name,
+            steps_completed: progress[:steps_completed] || [],
+            started_at: started_at,
+            updated_at: now
+          )
+
+          Aidp.log_debug("progress_repository", "step_in_progress",
+            mode: mode_str, step: step_name)
+        end
+
+        # Reset progress for a mode
+        #
+        # @param mode [String, Symbol] Mode
+        def reset(mode)
+          mode_str = mode.to_s
+          execute(
+            "DELETE FROM progress WHERE project_dir = ? AND mode = ?",
+            [project_dir, mode_str]
+          )
+
+          Aidp.log_debug("progress_repository", "reset", mode: mode_str)
+        end
+
+        # Get started_at timestamp
+        #
+        # @param mode [String, Symbol] Mode
+        # @return [Time, nil] Started at time
+        def started_at(mode)
+          progress = get(mode)
+          return nil unless progress[:started_at]
+
+          Time.parse(progress[:started_at])
+        rescue ArgumentError
+          nil
+        end
+
+        # Upsert progress data (for migrations and direct updates)
+        #
+        # @param mode [String] Mode (execute or analyze)
+        # @param current_step [String, nil] Current step name
+        # @param steps_completed [Array<String>] Completed step names
+        # @param started_at [String] Started at timestamp
+        # @param updated_at [String] Updated at timestamp
+        def upsert_progress(mode:, current_step:, steps_completed:, started_at:, updated_at:)
+          existing = query_one(
+            "SELECT id FROM progress WHERE project_dir = ? AND mode = ?",
+            [project_dir, mode]
+          )
+
+          if existing
+            execute(
+              <<~SQL,
+                UPDATE progress SET
+                  current_step = ?,
+                  steps_completed = ?,
+                  started_at = ?,
+                  updated_at = ?
+                WHERE project_dir = ? AND mode = ?
+              SQL
+              [
+                current_step,
+                serialize_json(steps_completed),
+                started_at,
+                updated_at,
+                project_dir,
+                mode
+              ]
+            )
+          else
+            execute(
+              insert_sql([
+                :project_dir, :mode, :current_step, :steps_completed,
+                :started_at, :updated_at
+              ]),
+              [
+                project_dir,
+                mode,
+                current_step,
+                serialize_json(steps_completed),
+                started_at,
+                updated_at
+              ]
+            )
+          end
+        end
+
+        private
+
+        def empty_progress(mode)
+          {
+            mode: mode,
+            current_step: nil,
+            steps_completed: [],
+            started_at: nil,
+            updated_at: nil
+          }
+        end
+
+        def deserialize_progress(row)
+          {
+            id: row["id"],
+            mode: row["mode"],
+            current_step: row["current_step"],
+            steps_completed: deserialize_json(row["steps_completed"]) || [],
+            started_at: row["started_at"],
+            updated_at: row["updated_at"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/repositories/prompt_archive_repository.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for prompt_archive table
+      # Replaces prompt_archive/*.md files
+      # Write-only audit trail of prompts
+      class PromptArchiveRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "prompt_archive")
+        end
+
+        # Archive a prompt
+        #
+        # @param step_name [String, nil] Step name
+        # @param content [String] Prompt content
+        # @return [Integer] Archive entry ID
+        def archive(step_name:, content:)
+          now = current_timestamp
+
+          execute(
+            insert_sql([:project_dir, :step_name, :content, :archived_at]),
+            [project_dir, step_name, content, now]
+          )
+
+          id = last_insert_row_id
+
+          Aidp.log_debug("prompt_archive_repository", "archived",
+            id: id, step: step_name, size: content.length)
+
+          id
+        end
+
+        # Get recent archived prompts
+        #
+        # @param limit [Integer] Maximum entries
+        # @param step_name [String, nil] Filter by step
+        # @return [Array<Hash>] Archive entries
+        def recent(limit: 50, step_name: nil)
+          rows = if step_name
+            query(
+              <<~SQL,
+                SELECT * FROM prompt_archive
+                WHERE project_dir = ? AND step_name = ?
+                ORDER BY archived_at DESC
+                LIMIT ?
+              SQL
+              [project_dir, step_name, limit]
+            )
+          else
+            query(
+              <<~SQL,
+                SELECT * FROM prompt_archive
+                WHERE project_dir = ?
+                ORDER BY archived_at DESC
+                LIMIT ?
+              SQL
+              [project_dir, limit]
+            )
+          end
+
+          rows.map { |row| deserialize_entry(row) }
+        end
+
+        # Get archive entry by ID
+        #
+        # @param id [Integer] Entry ID
+        # @return [Hash, nil] Entry or nil
+        def find(id)
+          row = query_one(
+            "SELECT * FROM prompt_archive WHERE id = ? AND project_dir = ?",
+            [id, project_dir]
+          )
+          deserialize_entry(row)
+        end
+
+        # Get latest archived prompt for a step
+        #
+        # @param step_name [String] Step name
+        # @return [Hash, nil] Latest entry or nil
+        def latest_for_step(step_name)
+          row = query_one(
+            <<~SQL,
+              SELECT * FROM prompt_archive
+              WHERE project_dir = ? AND step_name = ?
+              ORDER BY archived_at DESC, id DESC
+              LIMIT 1
+            SQL
+            [project_dir, step_name]
+          )
+          deserialize_entry(row)
+        end
+
+        # Get archive stats
+        #
+        # @return [Hash] Statistics
+        def stats
+          total = query_value(
+            "SELECT COUNT(*) FROM prompt_archive WHERE project_dir = ?",
+            [project_dir]
+          ) || 0
+
+          by_step_rows = query(
+            <<~SQL,
+              SELECT step_name, COUNT(*) as count
+              FROM prompt_archive
+              WHERE project_dir = ?
+              GROUP BY step_name
+            SQL
+            [project_dir]
+          )
+
+          by_step = by_step_rows.each_with_object({}) do |row, h|
+            h[row["step_name"] || "unknown"] = row["count"]
+          end
+
+          first = query_one(
+            "SELECT archived_at FROM prompt_archive WHERE project_dir = ? ORDER BY archived_at ASC LIMIT 1",
+            [project_dir]
+          )
+
+          last = query_one(
+            "SELECT archived_at FROM prompt_archive WHERE project_dir = ? ORDER BY archived_at DESC LIMIT 1",
+            [project_dir]
+          )
+
+          {
+            total: total,
+            by_step: by_step,
+            first_archived_at: first&.dig("archived_at"),
+            last_archived_at: last&.dig("archived_at")
+          }
+        end
+
+        # Search archived prompts
+        #
+        # @param query_text [String] Search text
+        # @param limit [Integer] Maximum results
+        # @return [Array<Hash>] Matching entries
+        def search(query_text, limit: 20)
+          rows = query(
+            <<~SQL,
+              SELECT * FROM prompt_archive
+              WHERE project_dir = ? AND content LIKE ?
+              ORDER BY archived_at DESC
+              LIMIT ?
+            SQL
+            [project_dir, "%#{query_text}%", limit]
+          )
+
+          rows.map { |row| deserialize_entry(row) }
+        end
+
+        # Clear old archives (keep recent N days)
+        #
+        # @param days_to_keep [Integer] Days of history to retain
+        # @return [Integer] Number of entries deleted
+        def cleanup(days_to_keep: 30)
+          threshold = (Time.now - (days_to_keep * 24 * 60 * 60)).strftime("%Y-%m-%d %H:%M:%S")
+
+          count = query_value(
+            "SELECT COUNT(*) FROM prompt_archive WHERE project_dir = ? AND archived_at < ?",
+            [project_dir, threshold]
+          ) || 0
+
+          execute(
+            "DELETE FROM prompt_archive WHERE project_dir = ? AND archived_at < ?",
+            [project_dir, threshold]
+          )
+
+          Aidp.log_debug("prompt_archive_repository", "cleanup",
+            deleted: count, threshold: threshold)
+
+          count
+        end
+
+        private
+
+        def deserialize_entry(row)
+          return nil unless row
+
+          {
+            id: row["id"],
+            step_name: row["step_name"],
+            content: row["content"],
+            archived_at: row["archived_at"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/repositories/prompt_feedback_repository.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for prompt_feedback table
+      # Tracks prompt template effectiveness for AGD evolution
+      class PromptFeedbackRepository < Repository
+        VALID_OUTCOMES = %w[success failure abandoned timeout].freeze
+        VALID_REACTIONS = %w[positive negative neutral].freeze
+
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "prompt_feedback")
+        end
+
+        # Record feedback for a prompt template
+        #
+        # @param record [Hash] Feedback data with keys:
+        #   - template_id [String] Template identifier
+        #   - outcome [String] success/failure/abandoned/timeout
+        #   - iterations [Integer, nil] Number of iterations to completion
+        #   - user_reaction [String, nil] positive/negative/neutral
+        #   - suggestions [Array<String>, nil] Improvement suggestions
+        #   - context [Hash, nil] Additional context
+        # @return [Hash] Result with :success and :id
+        def record(record)
+          execute(
+            insert_sql([
+              :project_dir, :template_id, :outcome, :iterations,
+              :user_reaction, :suggestions, :context, :aidp_version
+            ]),
+            [
+              project_dir,
+              record[:template_id],
+              record[:outcome].to_s,
+              record[:iterations],
+              record[:user_reaction]&.to_s,
+              serialize_json(record[:suggestions]),
+              serialize_json(record[:context] || {}),
+              Aidp::VERSION
+            ]
+          )
+
+          Aidp.log_debug("prompt_feedback_repository", "recorded",
+            template_id: record[:template_id], outcome: record[:outcome])
+
+          {success: true, id: last_insert_row_id}
+        rescue => e
+          Aidp.log_debug("prompt_feedback_repository", "record_failed",
+            template_id: record[:template_id], error: e.message)
+          {success: false, error: e.message}
+        end
+
+        # Get summary statistics for a template
+        #
+        # @param template_id [String] Template identifier
+        # @return [Hash] Summary statistics
+        def summary(template_id:)
+          total = query_value(
+            "SELECT COUNT(*) FROM prompt_feedback WHERE project_dir = ? AND template_id = ?",
+            [project_dir, template_id]
+          ) || 0
+
+          return empty_summary(template_id) if total.zero?
+
+          success_count = query_value(
+            "SELECT COUNT(*) FROM prompt_feedback WHERE project_dir = ? AND template_id = ? AND outcome = 'success'",
+            [project_dir, template_id]
+          ) || 0
+
+          failure_count = query_value(
+            "SELECT COUNT(*) FROM prompt_feedback WHERE project_dir = ? AND template_id = ? AND outcome = 'failure'",
+            [project_dir, template_id]
+          ) || 0
+
+          avg_iterations = query_value(
+            "SELECT AVG(iterations) FROM prompt_feedback WHERE project_dir = ? AND template_id = ? AND iterations IS NOT NULL",
+            [project_dir, template_id]
+          )
+
+          positive_reactions = query_value(
+            "SELECT COUNT(*) FROM prompt_feedback WHERE project_dir = ? AND template_id = ? AND user_reaction = 'positive'",
+            [project_dir, template_id]
+          ) || 0
+
+          negative_reactions = query_value(
+            "SELECT COUNT(*) FROM prompt_feedback WHERE project_dir = ? AND template_id = ? AND user_reaction = 'negative'",
+            [project_dir, template_id]
+          ) || 0
+
+          # Get suggestions
+          suggestion_rows = query(
+            "SELECT suggestions FROM prompt_feedback WHERE project_dir = ? AND template_id = ? AND suggestions IS NOT NULL",
+            [project_dir, template_id]
+          )
+          all_suggestions = suggestion_rows.flat_map { |r| deserialize_json(r["suggestions"]) || [] }.compact.uniq
+
+          first_row = query_one(
+            "SELECT created_at FROM prompt_feedback WHERE project_dir = ? AND template_id = ? ORDER BY created_at ASC LIMIT 1",
+            [project_dir, template_id]
+          )
+          last_row = query_one(
+            "SELECT created_at FROM prompt_feedback WHERE project_dir = ? AND template_id = ? ORDER BY created_at DESC LIMIT 1",
+            [project_dir, template_id]
+          )
+
+          {
+            template_id: template_id,
+            total_uses: total,
+            success_rate: (total > 0) ? (success_count.to_f / total * 100).round(1) : 0,
+            success_count: success_count,
+            failure_count: failure_count,
+            avg_iterations: avg_iterations&.round(1),
+            positive_reactions: positive_reactions,
+            negative_reactions: negative_reactions,
+            common_suggestions: all_suggestions.take(5),
+            first_use: first_row&.dig("created_at"),
+            last_use: last_row&.dig("created_at")
+          }
+        end
+
+        # List feedback entries with filtering
+        #
+        # @param template_id [String, nil] Filter by template
+        # @param outcome [String, nil] Filter by outcome
+        # @param limit [Integer] Maximum entries
+        # @return [Array<Hash>] Feedback entries
+        def list(template_id: nil, outcome: nil, limit: 100)
+          conditions = ["project_dir = ?"]
+          params = [project_dir]
+
+          if template_id
+            conditions << "template_id = ?"
+            params << template_id
+          end
+
+          if outcome
+            conditions << "outcome = ?"
+            params << outcome.to_s
+          end
+
+          params << limit
+
+          rows = query(
+            <<~SQL,
+              SELECT * FROM prompt_feedback
+              WHERE #{conditions.join(" AND ")}
+              ORDER BY created_at DESC, id DESC
+              LIMIT ?
+            SQL
+            params
+          )
+
+          rows.map { |row| deserialize_feedback(row) }
+        end
+
+        # Find templates that need improvement
+        #
+        # @param min_uses [Integer] Minimum uses to consider
+        # @param max_success_rate [Float] Success rate threshold
+        # @return [Array<Hash>] Templates needing improvement
+        def templates_needing_improvement(min_uses: 5, max_success_rate: 70.0)
+          # Use a single aggregated query instead of N+1 queries
+          rows = query(
+            <<~SQL,
+              SELECT
+                template_id,
+                COUNT(*) as total_uses,
+                SUM(CASE WHEN outcome = 'success' THEN 1 ELSE 0 END) as success_count,
+                SUM(CASE WHEN outcome = 'failure' THEN 1 ELSE 0 END) as failure_count,
+                AVG(CASE WHEN iterations IS NOT NULL THEN iterations END) as avg_iterations,
+                SUM(CASE WHEN user_reaction = 'positive' THEN 1 ELSE 0 END) as positive_reactions,
+                SUM(CASE WHEN user_reaction = 'negative' THEN 1 ELSE 0 END) as negative_reactions
+              FROM prompt_feedback
+              WHERE project_dir = ?
+              GROUP BY template_id
+              HAVING COUNT(*) >= ?
+            SQL
+            [project_dir, min_uses]
+          )
+
+          rows.filter_map do |row|
+            total = row["total_uses"]
+            success_count = row["success_count"]
+            success_rate = (total > 0) ? (success_count.to_f / total * 100).round(1) : 0
+
+            next if success_rate > max_success_rate
+
+            {
+              template_id: row["template_id"],
+              total_uses: total,
+              success_rate: success_rate,
+              success_count: success_count,
+              failure_count: row["failure_count"],
+              avg_iterations: row["avg_iterations"]&.round(1),
+              positive_reactions: row["positive_reactions"],
+              negative_reactions: row["negative_reactions"]
+            }
+          end.sort_by { |s| s[:success_rate] }
+        end
+
+        # Clear all feedback
+        #
+        # @return [Hash] Result with count
+        def clear
+          count = query_value(
+            "SELECT COUNT(*) FROM prompt_feedback WHERE project_dir = ?",
+            [project_dir]
+          ) || 0
+
+          execute("DELETE FROM prompt_feedback WHERE project_dir = ?", [project_dir])
+
+          Aidp.log_debug("prompt_feedback_repository", "cleared", count: count)
+          {success: true, count: count}
+        end
+
+        # Check if any feedback exists
+        #
+        # @return [Boolean]
+        def any?
+          count = query_value(
+            "SELECT COUNT(*) FROM prompt_feedback WHERE project_dir = ?",
+            [project_dir]
+          ) || 0
+          count.positive?
+        end
+
+        private
+
+        def deserialize_feedback(row)
+          return nil unless row
+
+          {
+            id: row["id"],
+            template_id: row["template_id"],
+            outcome: row["outcome"],
+            iterations: row["iterations"],
+            user_reaction: row["user_reaction"],
+            suggestions: deserialize_json(row["suggestions"]),
+            context: deserialize_json(row["context"]) || {},
+            aidp_version: row["aidp_version"],
+            created_at: row["created_at"]
+          }
+        end
+
+        def empty_summary(template_id)
+          {
+            template_id: template_id,
+            total_uses: 0,
+            success_rate: 0,
+            success_count: 0,
+            failure_count: 0,
+            avg_iterations: nil,
+            positive_reactions: 0,
+            negative_reactions: 0,
+            common_suggestions: [],
+            first_use: nil,
+            last_use: nil
+          }
+        end
+      end
+    end
+  end
+end