aidp 0.3.0 → 0.7.0

data/lib/aidp/analyze/storage.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "sqlite3"
+require "pg"
 require "json"
 require "yaml"
 
@@ -12,7 +12,6 @@ module Aidp
     def initialize(project_dir = Dir.pwd, config = {})
       @project_dir = project_dir
       @config = config
-      @db_path = config[:db_path] || File.join(project_dir, ".aidp-analysis.db")
       @db = nil
 
       ensure_database_exists
@@ -36,14 +35,24 @@ module Aidp
       }
 
       # Insert or update analysis result
-      @db.execute(
-        "INSERT OR REPLACE INTO analysis_results (execution_id, step_name, data, metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
-        execution_id,
-        step_name,
-        JSON.generate(data),
-        JSON.generate(analysis_data[:metadata]),
-        timestamp.to_i,
-        timestamp.to_i
+      @db.exec_params(
+        <<~SQL,
+          INSERT INTO analysis_results (execution_id, step_name, data, metadata, created_at, updated_at)
+          VALUES ($1, $2, $3, $4, $5, $6)
+          ON CONFLICT (execution_id, step_name)
+          DO UPDATE SET
+            data = EXCLUDED.data,
+            metadata = EXCLUDED.metadata,
+            updated_at = EXCLUDED.updated_at
+        SQL
+        [
+          execution_id,
+          step_name,
+          data.to_json,
+          analysis_data[:metadata].to_json,
+          timestamp,
+          timestamp
+        ]
       )
 
       # Store metrics with indefinite retention
@@ -55,13 +64,6 @@ module Aidp
         stored_at: timestamp,
         success: true
       }
-    rescue => e
-      {
-        success: false,
-        error: e.message,
-        execution_id: execution_id,
-        step_name: step_name
-      }
     end
 
     # Store metrics with indefinite retention
@@ -72,14 +74,19 @@ module Aidp
       metrics = extract_metrics(data)
 
       metrics.each do |metric_name, metric_value|
-        @db.execute(
-          "INSERT INTO metrics (execution_id, step_name, metric_name, metric_value, metric_type, created_at) VALUES (?, ?, ?, ?, ?, ?)",
-          execution_id,
-          step_name,
-          metric_name,
-          metric_value.to_s,
-          metric_value.class.name,
-          timestamp.to_i
+        @db.exec_params(
+          <<~SQL,
+            INSERT INTO metrics (execution_id, step_name, metric_name, metric_value, metric_type, created_at)
+            VALUES ($1, $2, $3, $4, $5, $6)
+          SQL
+          [
+            execution_id,
+            step_name,
+            metric_name,
+            metric_value.to_s,
+            metric_value.class.name,
+            timestamp
+          ]
         )
       end
 
@@ -93,28 +100,35 @@ module Aidp
 
       result = if step_name
         # Get specific step result
-        @db.execute(
-          "SELECT * FROM analysis_results WHERE execution_id = ? AND step_name = ? ORDER BY updated_at DESC LIMIT 1",
-          execution_id,
-          step_name
-        ).first
+        @db.exec_params(
+          <<~SQL,
+            SELECT * FROM analysis_results
+            WHERE execution_id = $1 AND step_name = $2
+            ORDER BY updated_at DESC
+            LIMIT 1
+          SQL
+          [execution_id, step_name]
+        )
       else
         # Get all results for execution
-        @db.execute(
-          "SELECT * FROM analysis_results WHERE execution_id = ? ORDER BY updated_at DESC",
-          execution_id
+        @db.exec_params(
+          <<~SQL,
+            SELECT * FROM analysis_results
+            WHERE execution_id = $1
+            ORDER BY updated_at DESC
+          SQL
+          [execution_id]
         )
       end
 
-      return nil unless result
+      return nil if result.ntuples.zero?
 
-      if result.is_a?(Array) && result.length > 1
+      if result.ntuples > 1
         # Multiple results
         result.map { |row| parse_analysis_result(row) }
       else
         # Single result
-        row = result.is_a?(Array) ? result.first : result
-        parse_analysis_result(row)
+        parse_analysis_result(result[0])
       end
     end
 
@@ -124,26 +138,31 @@ module Aidp
 
       query = "SELECT * FROM metrics WHERE 1=1"
       params = []
+      param_index = 1
 
       if execution_id
-        query += " AND execution_id = ?"
+        query += " AND execution_id = $#{param_index}"
         params << execution_id
+        param_index += 1
       end
 
       if step_name
-        query += " AND step_name = ?"
+        query += " AND step_name = $#{param_index}"
         params << step_name
+        param_index += 1
       end
 
       if metric_name
-        query += " AND metric_name = ?"
+        query += " AND metric_name = $#{param_index}"
         params << metric_name
+        param_index += 1
       end
 
-      query += " ORDER BY created_at DESC LIMIT ?"
+      query += " ORDER BY created_at DESC"
+      query += " LIMIT $#{param_index}"
       params << limit
 
-      results = @db.execute(query, *params)
+      results = @db.exec_params(query, params)
       results.map { |row| parse_metric(row) }
     end
 
@@ -153,25 +172,29 @@ module Aidp
 
       query = "SELECT * FROM aggregated_metrics WHERE 1=1"
       params = []
+      param_index = 1
 
       if execution_id
-        query += " AND execution_id = ?"
+        query += " AND execution_id = $#{param_index}"
         params << execution_id
+        param_index += 1
       end
 
       if step_name
-        query += " AND step_name = ?"
+        query += " AND step_name = $#{param_index}"
         params << step_name
+        param_index += 1
       end
 
       if metric_name
-        query += " AND metric_name = ?"
+        query += " AND metric_name = $#{param_index}"
         params << metric_name
+        param_index + 1
       end
 
       query += " ORDER BY created_at DESC"
 
-      results = @db.execute(query, *params)
+      results = @db.exec_params(query, params)
       results.map { |row| parse_aggregated_metric(row) }
     end
 
@@ -179,9 +202,14 @@ module Aidp
     def get_execution_history(limit = 50)
       ensure_connection
 
-      results = @db.execute(
-        "SELECT DISTINCT execution_id, step_name, created_at, updated_at FROM analysis_results ORDER BY created_at DESC LIMIT ?",
-        limit
+      results = @db.exec_params(
+        <<~SQL,
+          SELECT DISTINCT execution_id, step_name, created_at, updated_at
+          FROM analysis_results
+          ORDER BY created_at DESC
+          LIMIT $1
+        SQL
+        [limit]
       )
 
       results.map { |row| parse_execution_history(row) }
@@ -194,30 +222,34 @@ module Aidp
       stats = {}
 
       # Total executions
-      total_executions = @db.execute("SELECT COUNT(DISTINCT execution_id) FROM analysis_results").first[0]
+      total_executions = @db.exec("SELECT COUNT(DISTINCT execution_id) FROM analysis_results").first["count"].to_i
       stats[:total_executions] = total_executions
 
       # Total steps
-      total_steps = @db.execute("SELECT COUNT(*) FROM analysis_results").first[0]
+      total_steps = @db.exec("SELECT COUNT(*) FROM analysis_results").first["count"].to_i
       stats[:total_steps] = total_steps
 
       # Steps by type
-      steps_by_type = @db.execute("SELECT step_name, COUNT(*) FROM analysis_results GROUP BY step_name")
-      stats[:steps_by_type] = steps_by_type.to_h
+      steps_by_type = @db.exec("SELECT step_name, COUNT(*) FROM analysis_results GROUP BY step_name")
+      stats[:steps_by_type] = steps_by_type.each_with_object({}) do |row, hash|
+        hash[row["step_name"]] = row["count"].to_i
+      end
 
       # Total metrics
-      total_metrics = @db.execute("SELECT COUNT(*) FROM metrics").first[0]
+      total_metrics = @db.exec("SELECT COUNT(*) FROM metrics").first["count"].to_i
       stats[:total_metrics] = total_metrics
 
       # Metrics by type
-      metrics_by_type = @db.execute("SELECT metric_name, COUNT(*) FROM metrics GROUP BY metric_name")
-      stats[:metrics_by_type] = metrics_by_type.to_h
+      metrics_by_type = @db.exec("SELECT metric_name, COUNT(*) FROM metrics GROUP BY metric_name")
+      stats[:metrics_by_type] = metrics_by_type.each_with_object({}) do |row, hash|
+        hash[row["metric_name"]] = row["count"].to_i
+      end
 
       # Date range
-      date_range = @db.execute("SELECT MIN(created_at), MAX(created_at) FROM analysis_results").first
+      date_range = @db.exec("SELECT MIN(created_at), MAX(created_at) FROM analysis_results").first
       stats[:date_range] = {
-        earliest: date_range[0] ? Time.at(date_range[0]) : nil,
-        latest: date_range[1] ? Time.at(date_range[1]) : nil
+        earliest: date_range["min"] ? Time.parse(date_range["min"]) : nil,
+        latest: date_range["max"] ? Time.parse(date_range["max"]) : nil
       }
 
       stats
@@ -228,10 +260,9 @@ module Aidp
       ensure_connection
 
       # Delete existing analysis result
-      @db.execute(
-        "DELETE FROM analysis_results WHERE execution_id = ? AND step_name = ?",
-        execution_id,
-        step_name
+      @db.exec_params(
+        "DELETE FROM analysis_results WHERE execution_id = $1 AND step_name = $2",
+        [execution_id, step_name]
       )
 
       # Store new analysis result
@@ -243,17 +274,16 @@ module Aidp
       ensure_connection
 
       if execution_id && step_name
-        @db.execute(
-          "DELETE FROM analysis_results WHERE execution_id = ? AND step_name = ?",
-          execution_id,
-          step_name
+        @db.exec_params(
+          "DELETE FROM analysis_results WHERE execution_id = $1 AND step_name = $2",
+          [execution_id, step_name]
         )
       elsif execution_id
-        @db.execute("DELETE FROM analysis_results WHERE execution_id = ?", execution_id)
+        @db.exec_params("DELETE FROM analysis_results WHERE execution_id = $1", [execution_id])
       elsif step_name
-        @db.execute("DELETE FROM analysis_results WHERE step_name = ?", step_name)
+        @db.exec_params("DELETE FROM analysis_results WHERE step_name = $1", [step_name])
       else
-        @db.execute("DELETE FROM analysis_results")
+        @db.exec("DELETE FROM analysis_results")
       end
 
       {success: true, deleted_execution_id: execution_id, deleted_step_name: step_name}
@@ -295,27 +325,43 @@ module Aidp
 
       # Import analysis results
       parsed_data["analysis_results"]&.each do |result|
-        @db.execute(
-          "INSERT OR REPLACE INTO analysis_results (execution_id, step_name, data, metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
-          result["execution_id"],
-          result["step_name"],
-          result["data"],
-          result["metadata"],
-          result["created_at"],
-          result["updated_at"]
+        @db.exec_params(
+          <<~SQL,
+            INSERT INTO analysis_results (execution_id, step_name, data, metadata, created_at, updated_at)
+            VALUES ($1, $2, $3, $4, $5, $6)
+            ON CONFLICT (execution_id, step_name)
+            DO UPDATE SET
+              data = EXCLUDED.data,
+              metadata = EXCLUDED.metadata,
+              updated_at = EXCLUDED.updated_at
+          SQL
+          [
+            result["execution_id"],
+            result["step_name"],
+            result["data"],
+            result["metadata"],
+            result["created_at"],
+            result["updated_at"]
+          ]
         )
       end
 
       # Import metrics
       parsed_data["metrics"]&.each do |metric|
-        @db.execute(
-          "INSERT OR REPLACE INTO metrics (execution_id, step_name, metric_name, metric_value, metric_type, created_at) VALUES (?, ?, ?, ?, ?, ?)",
-          metric["execution_id"],
-          metric["step_name"],
-          metric["metric_name"],
-          metric["metric_value"],
-          metric["metric_type"],
-          metric["created_at"]
+        @db.exec_params(
+          <<~SQL,
+            INSERT INTO metrics (execution_id, step_name, metric_name, metric_value, metric_type, created_at)
+            VALUES ($1, $2, $3, $4, $5, $6)
+            ON CONFLICT DO NOTHING
+          SQL
+          [
+            metric["execution_id"],
+            metric["step_name"],
+            metric["metric_name"],
+            metric["metric_value"],
+            metric["metric_type"],
+            metric["created_at"]
+          ]
         )
       end
 
@@ -331,71 +377,78 @@ module Aidp
     private
 
     def ensure_database_exists
-      return if File.exist?(@db_path)
-
-      @db = SQLite3::Database.new(@db_path)
+      ensure_connection
       create_schema
     end
 
     def ensure_connection
-      @db ||= SQLite3::Database.new(@db_path)
+      return if @db
+
+      @db = PG.connect(
+        host: ENV["AIDP_DB_HOST"] || "localhost",
+        port: ENV["AIDP_DB_PORT"] || 5432,
+        dbname: ENV["AIDP_DB_NAME"] || "aidp",
+        user: ENV["AIDP_DB_USER"] || ENV["USER"],
+        password: ENV["AIDP_DB_PASSWORD"]
+      )
+      @db.type_map_for_results = PG::BasicTypeMapForResults.new(@db)
     end
 
     def create_schema
       # Create analysis_results table
-      @db.execute(<<~SQL)
+      @db.exec(<<~SQL)
         CREATE TABLE IF NOT EXISTS analysis_results (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          id SERIAL PRIMARY KEY,
           execution_id TEXT NOT NULL,
           step_name TEXT NOT NULL,
-          data TEXT NOT NULL,
-          metadata TEXT,
-          created_at INTEGER NOT NULL,
-          updated_at INTEGER NOT NULL,
+          data JSONB NOT NULL,
+          metadata JSONB,
+          created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+          updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
           UNIQUE(execution_id, step_name)
         )
       SQL
 
       # Create metrics table (indefinite retention)
-      @db.execute(<<~SQL)
+      @db.exec(<<~SQL)
         CREATE TABLE IF NOT EXISTS metrics (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          id SERIAL PRIMARY KEY,
           execution_id TEXT NOT NULL,
           step_name TEXT NOT NULL,
           metric_name TEXT NOT NULL,
           metric_value TEXT NOT NULL,
           metric_type TEXT NOT NULL,
-          created_at INTEGER NOT NULL
+          created_at TIMESTAMP WITH TIME ZONE NOT NULL
         )
       SQL
 
       # Create aggregated_metrics table
-      @db.execute(<<~SQL)
+      @db.exec(<<~SQL)
         CREATE TABLE IF NOT EXISTS aggregated_metrics (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          id SERIAL PRIMARY KEY,
           execution_id TEXT NOT NULL,
           step_name TEXT NOT NULL,
           metric_name TEXT NOT NULL,
-          min_value REAL,
-          max_value REAL,
-          avg_value REAL,
+          min_value DOUBLE PRECISION,
+          max_value DOUBLE PRECISION,
+          avg_value DOUBLE PRECISION,
           count INTEGER NOT NULL,
-          created_at INTEGER NOT NULL
+          created_at TIMESTAMP WITH TIME ZONE NOT NULL
         )
       SQL
 
       # Create indexes
-      @db.execute("CREATE INDEX IF NOT EXISTS idx_analysis_results_execution_id ON analysis_results(execution_id)")
-      @db.execute("CREATE INDEX IF NOT EXISTS idx_analysis_results_step_name ON analysis_results(step_name)")
-      @db.execute("CREATE INDEX IF NOT EXISTS idx_analysis_results_created_at ON analysis_results(created_at)")
-      @db.execute("CREATE INDEX IF NOT EXISTS idx_metrics_execution_id ON metrics(execution_id)")
-      @db.execute("CREATE INDEX IF NOT EXISTS idx_metrics_step_name ON metrics(step_name)")
-      @db.execute("CREATE INDEX IF NOT EXISTS idx_metrics_metric_name ON metrics(metric_name)")
-      @db.execute("CREATE INDEX IF NOT EXISTS idx_metrics_created_at ON metrics(created_at)")
+      @db.exec("CREATE INDEX IF NOT EXISTS idx_analysis_results_execution_id ON analysis_results(execution_id)")
+      @db.exec("CREATE INDEX IF NOT EXISTS idx_analysis_results_step_name ON analysis_results(step_name)")
+      @db.exec("CREATE INDEX IF NOT EXISTS idx_analysis_results_created_at ON analysis_results(created_at)")
+      @db.exec("CREATE INDEX IF NOT EXISTS idx_metrics_execution_id ON metrics(execution_id)")
+      @db.exec("CREATE INDEX IF NOT EXISTS idx_metrics_step_name ON metrics(step_name)")
+      @db.exec("CREATE INDEX IF NOT EXISTS idx_metrics_metric_name ON metrics(metric_name)")
+      @db.exec("CREATE INDEX IF NOT EXISTS idx_metrics_created_at ON metrics(created_at)")
 
       # Store schema version
-      @db.execute("CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL)")
-      @db.execute("INSERT OR REPLACE INTO schema_version (version) VALUES (?)", SCHEMA_VERSION)
+      @db.exec("CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL)")
+      @db.exec_params("INSERT INTO schema_version (version) VALUES ($1) ON CONFLICT DO NOTHING", [SCHEMA_VERSION])
     end
 
     def generate_execution_id
@@ -436,41 +489,37 @@ module Aidp
         next unless metric_value.is_a?(Numeric)
 
         # Get existing aggregated metric
-        existing = @db.execute(
-          "SELECT * FROM aggregated_metrics WHERE execution_id = ? AND step_name = ? AND metric_name = ?",
-          execution_id,
-          step_name,
-          metric_name
+        existing = @db.exec_params(
+          <<~SQL,
+            SELECT * FROM aggregated_metrics
+            WHERE execution_id = $1 AND step_name = $2 AND metric_name = $3
+          SQL
+          [execution_id, step_name, metric_name]
         ).first
 
         if existing
           # Update existing aggregated metric
-          count = existing[7] + 1
-          min_value = [existing[3], metric_value].min
-          max_value = [existing[4], metric_value].max
-          avg_value = ((existing[5] * existing[7]) + metric_value) / count
-
-          @db.execute(
-            "UPDATE aggregated_metrics SET min_value = ?, max_value = ?, avg_value = ?, count = ?, created_at = ? WHERE id = ?",
-            min_value,
-            max_value,
-            avg_value,
-            count,
-            timestamp.to_i,
-            existing[0]
+          count = existing["count"].to_i + 1
+          min_value = [existing["min_value"].to_f, metric_value].min
+          max_value = [existing["max_value"].to_f, metric_value].max
+          avg_value = ((existing["avg_value"].to_f * existing["count"].to_i) + metric_value) / count
+
+          @db.exec_params(
+            <<~SQL,
+              UPDATE aggregated_metrics
+              SET min_value = $1, max_value = $2, avg_value = $3, count = $4, created_at = $5
+              WHERE id = $6
+            SQL
+            [min_value, max_value, avg_value, count, timestamp, existing["id"]]
           )
         else
           # Create new aggregated metric
-          @db.execute(
-            "INSERT INTO aggregated_metrics (execution_id, step_name, metric_name, min_value, max_value, avg_value, count, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-            execution_id,
-            step_name,
-            metric_name,
-            metric_value,
-            metric_value,
-            metric_value,
-            1,
-            timestamp.to_i
+          @db.exec_params(
+            <<~SQL,
+              INSERT INTO aggregated_metrics (execution_id, step_name, metric_name, min_value, max_value, avg_value, count, created_at)
+              VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+            SQL
+            [execution_id, step_name, metric_name, metric_value, metric_value, metric_value, 1, timestamp]
           )
         end
       end
@@ -480,13 +529,13 @@ module Aidp
       return nil unless row
 
       {
-        id: row[0],
-        execution_id: row[1],
-        step_name: row[2],
-        data: JSON.parse(row[3]),
-        metadata: JSON.parse(row[4] || "{}"),
-        created_at: Time.at(row[5]),
-        updated_at: Time.at(row[6])
+        id: row["id"].to_i,
+        execution_id: row["execution_id"],
+        step_name: row["step_name"],
+        data: JSON.parse(row["data"]),
+        metadata: JSON.parse(row["metadata"] || "{}"),
+        created_at: Time.parse(row["created_at"]),
+        updated_at: Time.parse(row["updated_at"])
       }
     end
 
@@ -494,13 +543,13 @@ module Aidp
       return nil unless row
 
       {
-        id: row[0],
-        execution_id: row[1],
-        step_name: row[2],
-        metric_name: row[3],
-        metric_value: row[4],
-        metric_type: row[5],
-        created_at: Time.at(row[6])
+        id: row["id"].to_i,
+        execution_id: row["execution_id"],
+        step_name: row["step_name"],
+        metric_name: row["metric_name"],
+        metric_value: row["metric_value"],
+        metric_type: row["metric_type"],
+        created_at: Time.parse(row["created_at"])
       }
     end
 
@@ -508,15 +557,15 @@ module Aidp
       return nil unless row
 
       {
-        id: row[0],
-        execution_id: row[1],
-        step_name: row[2],
-        metric_name: row[3],
-        min_value: row[4],
-        max_value: row[5],
-        avg_value: row[6],
-        count: row[7],
-        created_at: Time.at(row[8])
+        id: row["id"].to_i,
+        execution_id: row["execution_id"],
+        step_name: row["step_name"],
+        metric_name: row["metric_name"],
+        min_value: row["min_value"].to_f,
+        max_value: row["max_value"].to_f,
+        avg_value: row["avg_value"].to_f,
+        count: row["count"].to_i,
+        created_at: Time.parse(row["created_at"])
       }
     end
 
@@ -524,10 +573,10 @@ module Aidp
       return nil unless row
 
       {
-        execution_id: row[0],
-        step_name: row[1],
-        created_at: Time.at(row[2]),
-        updated_at: Time.at(row[3])
+        execution_id: row["execution_id"],
+        step_name: row["step_name"],
+        created_at: Time.parse(row["created_at"]),
+        updated_at: Time.parse(row["updated_at"])
       }
     end
 
@@ -536,20 +585,22 @@ module Aidp
 
       query = "SELECT * FROM analysis_results"
       params = []
+      param_index = 1
 
       if options[:execution_id]
-        query += " WHERE execution_id = ?"
+        query += " WHERE execution_id = $#{param_index}"
         params << options[:execution_id]
+        param_index += 1
       end
 
       query += " ORDER BY created_at DESC"
 
       if options[:limit]
-        query += " LIMIT ?"
+        query += " LIMIT $#{param_index}"
         params << options[:limit]
       end
 
-      results = @db.execute(query, *params)
+      results = @db.exec_params(query, params)
       results.map { |row| parse_analysis_result(row) }
     end
 
@@ -558,20 +609,22 @@ module Aidp
 
       query = "SELECT * FROM metrics"
       params = []
+      param_index = 1
 
       if options[:execution_id]
-        query += " WHERE execution_id = ?"
+        query += " WHERE execution_id = $#{param_index}"
         params << options[:execution_id]
+        param_index += 1
       end
 
       query += " ORDER BY created_at DESC"
 
       if options[:limit]
-        query += " LIMIT ?"
+        query += " LIMIT $#{param_index}"
         params << options[:limit]
       end
 
-      results = @db.execute(query, *params)
+      results = @db.exec_params(query, params)
       results.map { |row| parse_metric(row) }
     end
 
@@ -580,20 +633,22 @@ module Aidp
 
       query = "SELECT * FROM aggregated_metrics"
       params = []
+      param_index = 1
 
       if options[:execution_id]
-        query += " WHERE execution_id = ?"
+        query += " WHERE execution_id = $#{param_index}"
         params << options[:execution_id]
+        param_index += 1
       end
 
       query += " ORDER BY created_at DESC"
 
       if options[:limit]
-        query += " LIMIT ?"
+        query += " LIMIT $#{param_index}"
         params << options[:limit]
       end
 
-      results = @db.execute(query, *params)
+      results = @db.exec_params(query, params)
       results.map { |row| parse_aggregated_metric(row) }
     end
   end