aidp 0.34.0 → 0.39.3

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

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for workstreams and workstream_events tables
+      # Replaces workstreams/*/state.json and history.jsonl
+      class WorkstreamRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "workstreams")
+        end
+
+        # Initialize a new workstream
+        #
+        # @param slug [String] Workstream slug
+        # @param task [String, nil] Task description
+        # @return [Hash] Created workstream state
+        def init(slug:, task: nil)
+          now = current_timestamp
+
+          execute(
+            insert_sql([
+              :project_dir, :slug, :status, :iteration, :metadata,
+              :created_at, :updated_at
+            ]),
+            [
+              project_dir,
+              slug,
+              "active",
+              0,
+              serialize_json({task: task, started_at: now}),
+              now,
+              now
+            ]
+          )
+
+          append_event(slug: slug, type: "created", data: {task: task})
+
+          Aidp.log_debug("workstream_repository", "initialized", slug: slug)
+
+          read(slug: slug)
+        end
+
+        # Read workstream state
+        #
+        # @param slug [String] Workstream slug
+        # @return [Hash, nil] Workstream state or nil
+        def read(slug:)
+          row = query_one(
+            "SELECT * FROM workstreams WHERE project_dir = ? AND slug = ?",
+            [project_dir, slug]
+          )
+          return nil unless row
+
+          deserialize_workstream(row)
+        end
+
+        # Update workstream attributes
+        #
+        # @param slug [String] Workstream slug
+        # @param attrs [Hash] Attributes to update
+        # @return [Hash] Updated workstream state
+        def update(slug:, **attrs)
+          existing = read(slug: slug)
+          existing ||= init(slug: slug)
+
+          now = current_timestamp
+          metadata = existing[:metadata] || {}
+          metadata = metadata.merge(attrs.except(:status, :iteration, :branch, :worktree_path))
+
+          execute(
+            <<~SQL,
+              UPDATE workstreams SET
+                status = ?,
+                iteration = ?,
+                branch = ?,
+                worktree_path = ?,
+                metadata = ?,
+                updated_at = ?
+              WHERE project_dir = ? AND slug = ?
+            SQL
+            [
+              attrs[:status] || existing[:status],
+              attrs[:iteration] || existing[:iteration],
+              attrs[:branch] || existing[:branch],
+              attrs[:worktree_path] || existing[:worktree_path],
+              serialize_json(metadata),
+              now,
+              project_dir,
+              slug
+            ]
+          )
+
+          Aidp.log_debug("workstream_repository", "updated", slug: slug)
+
+          read(slug: slug)
+        end
+
+        # Increment iteration counter
+        #
+        # @param slug [String] Workstream slug
+        # @return [Hash] Updated workstream state
+        def increment_iteration(slug:)
+          existing = read(slug: slug)
+          existing ||= init(slug: slug)
+
+          new_iteration = (existing[:iteration] || 0) + 1
+          new_status = (existing[:status] == "paused") ? "active" : existing[:status]
+
+          state = update(slug: slug, iteration: new_iteration, status: new_status)
+
+          append_event(slug: slug, type: "iteration", data: {count: new_iteration})
+
+          state
+        end
+
+        # Append event to workstream history
+        #
+        # @param slug [String] Workstream slug
+        # @param type [String] Event type
+        # @param data [Hash] Event data
+        def append_event(slug:, type:, data: {})
+          now = current_timestamp
+
+          execute(
+            <<~SQL,
+              INSERT INTO workstream_events
+                (project_dir, workstream_slug, event_type, event_data, timestamp)
+              VALUES (?, ?, ?, ?, ?)
+            SQL
+            [project_dir, slug, type, serialize_json(data), now]
+          )
+
+          Aidp.log_debug("workstream_repository", "event_appended",
+            slug: slug, type: type)
+        end
+
+        # Get recent events for workstream
+        #
+        # @param slug [String] Workstream slug
+        # @param limit [Integer] Maximum events to return
+        # @return [Array<Hash>] Recent events
+        def recent_events(slug:, limit: 5)
+          rows = query(
+            <<~SQL,
+              SELECT * FROM workstream_events
+              WHERE project_dir = ? AND workstream_slug = ?
+              ORDER BY timestamp DESC
+              LIMIT ?
+            SQL
+            [project_dir, slug, limit]
+          )
+
+          rows.map { |row| deserialize_event(row) }.reverse
+        end
+
+        # Pause workstream
+        #
+        # @param slug [String] Workstream slug
+        # @return [Hash] Result with status or error
+        def pause(slug:)
+          state = read(slug: slug)
+          return {error: "Workstream not found"} unless state
+          return {error: "Already paused"} if state[:status] == "paused"
+
+          now = current_timestamp
+          update(slug: slug, status: "paused", paused_at: now)
+          append_event(slug: slug, type: "paused", data: {})
+
+          {status: "paused"}
+        end
+
+        # Resume workstream
+        #
+        # @param slug [String] Workstream slug
+        # @return [Hash] Result with status or error
+        def resume(slug:)
+          state = read(slug: slug)
+          return {error: "Workstream not found"} unless state
+          return {error: "Not paused"} unless state[:status] == "paused"
+
+          now = current_timestamp
+          update(slug: slug, status: "active", resumed_at: now)
+          append_event(slug: slug, type: "resumed", data: {})
+
+          {status: "active"}
+        end
+
+        # Complete workstream
+        #
+        # @param slug [String] Workstream slug
+        # @return [Hash] Result with status or error
+        def complete(slug:)
+          state = read(slug: slug)
+          return {error: "Workstream not found"} unless state
+          return {error: "Already completed"} if state[:status] == "completed"
+
+          now = current_timestamp
+          update(slug: slug, status: "completed", completed_at: now)
+          append_event(slug: slug, type: "completed", data: {iterations: state[:iteration]})
+
+          {status: "completed"}
+        end
+
+        # Mark workstream as removed
+        #
+        # @param slug [String] Workstream slug
+        def mark_removed(slug:)
+          state = read(slug: slug)
+
+          # Auto-complete if active
+          complete(slug: slug) if state && state[:status] == "active"
+
+          update(slug: slug, status: "removed")
+          append_event(slug: slug, type: "removed", data: {})
+
+          Aidp.log_debug("workstream_repository", "removed", slug: slug)
+        end
+
+        # Check if workstream is stalled
+        #
+        # @param slug [String] Workstream slug
+        # @param threshold_seconds [Integer] Stall threshold in seconds
+        # @return [Boolean]
+        def stalled?(slug:, threshold_seconds: 3600)
+          state = read(slug: slug)
+          return false unless state && state[:updated_at]
+          return false if state[:status] != "active"
+
+          updated = Time.parse(state[:updated_at])
+          (Time.now.utc - updated).to_i > threshold_seconds
+        rescue ArgumentError
+          false
+        end
+
+        # Get elapsed time for workstream
+        #
+        # @param slug [String] Workstream slug
+        # @return [Integer] Elapsed seconds
+        def elapsed_seconds(slug:)
+          state = read(slug: slug)
+          return 0 unless state
+
+          metadata = state[:metadata] || {}
+          return 0 unless metadata[:started_at]
+
+          started = Time.parse(metadata[:started_at])
+          (Time.now.utc - started).to_i
+        rescue ArgumentError
+          0
+        end
+
+        # List all workstreams for project
+        #
+        # @param status [String, nil] Filter by status
+        # @return [Array<Hash>] Workstreams
+        def list(status: nil)
+          rows = if status
+            query(
+              "SELECT * FROM workstreams WHERE project_dir = ? AND status = ? ORDER BY updated_at DESC",
+              [project_dir, status]
+            )
+          else
+            query(
+              "SELECT * FROM workstreams WHERE project_dir = ? ORDER BY updated_at DESC",
+              [project_dir]
+            )
+          end
+
+          rows.map { |row| deserialize_workstream(row) }
+        end
+
+        private
+
+        def deserialize_workstream(row)
+          metadata = deserialize_json(row["metadata"]) || {}
+
+          {
+            id: row["id"],
+            slug: row["slug"],
+            status: row["status"],
+            iteration: row["iteration"] || 0,
+            branch: row["branch"],
+            worktree_path: row["worktree_path"],
+            metadata: metadata,
+            task: metadata[:task],
+            started_at: metadata[:started_at],
+            paused_at: metadata[:paused_at],
+            resumed_at: metadata[:resumed_at],
+            completed_at: metadata[:completed_at],
+            created_at: row["created_at"],
+            updated_at: row["updated_at"]
+          }
+        end
+
+        def deserialize_event(row)
+          {
+            id: row["id"],
+            workstream_slug: row["workstream_slug"],
+            type: row["event_type"],
+            data: deserialize_json(row["event_data"]) || {},
+            timestamp: row["timestamp"]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for worktrees table
+      # Replaces worktrees.json and pr_worktrees.json
+      # Handles both standard and PR worktrees
+      class WorktreeRepository < Repository
+        TYPES = %w[standard pr].freeze
+
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "worktrees")
+        end
+
+        # Register a standard worktree
+        #
+        # @param slug [String] Worktree slug
+        # @param path [String] Filesystem path
+        # @param branch [String] Branch name
+        # @return [Hash] Worktree info
+        def register(slug:, path:, branch:)
+          now = current_timestamp
+
+          execute(
+            insert_sql([
+              :project_dir, :worktree_type, :path, :branch, :slug,
+              :status, :created_at, :updated_at
+            ]),
+            [project_dir, "standard", path, branch, slug, "active", now, now]
+          )
+
+          Aidp.log_debug("worktree_repository", "registered",
+            slug: slug, type: "standard")
+
+          find_by_slug(slug)
+        end
+
+        # Register a PR worktree
+        #
+        # @param pr_number [Integer] PR number
+        # @param path [String] Filesystem path
+        # @param base_branch [String] Base branch
+        # @param head_branch [String] Head branch
+        # @param metadata [Hash] Additional metadata
+        # @return [Hash] Worktree info
+        def register_pr(pr_number:, path:, base_branch:, head_branch:, metadata: {})
+          now = current_timestamp
+          slug = "pr-#{pr_number}-#{Time.now.to_i}"
+
+          full_metadata = metadata.merge(
+            base_branch: base_branch,
+            head_branch: head_branch,
+            created_at: Time.now.to_i
+          )
+
+          execute(
+            insert_sql([
+              :project_dir, :worktree_type, :path, :branch, :slug, :pr_number,
+              :status, :metadata, :created_at, :updated_at
+            ]),
+            [
+              project_dir, "pr", path, head_branch, slug, pr_number,
+              "active", serialize_json(full_metadata), now, now
+            ]
+          )
+
+          Aidp.log_debug("worktree_repository", "registered_pr",
+            pr_number: pr_number, slug: slug)
+
+          find_by_pr(pr_number)
+        end
+
+        # Find worktree by slug
+        #
+        # @param slug [String] Worktree slug
+        # @return [Hash, nil] Worktree info or nil
+        def find_by_slug(slug)
+          row = query_one(
+            "SELECT * FROM worktrees WHERE project_dir = ? AND slug = ?",
+            [project_dir, slug]
+          )
+          deserialize_worktree(row)
+        end
+
+        # Find worktree by PR number
+        #
+        # @param pr_number [Integer] PR number
+        # @return [Hash, nil] Worktree info or nil
+        def find_by_pr(pr_number)
+          row = query_one(
+            "SELECT * FROM worktrees WHERE project_dir = ? AND pr_number = ?",
+            [project_dir, pr_number]
+          )
+          deserialize_worktree(row)
+        end
+
+        # Find worktree by branch
+        #
+        # @param branch [String] Branch name
+        # @return [Hash, nil] Worktree info or nil
+        def find_by_branch(branch)
+          row = query_one(
+            "SELECT * FROM worktrees WHERE project_dir = ? AND branch = ?",
+            [project_dir, branch]
+          )
+          deserialize_worktree(row)
+        end
+
+        # Check if worktree exists
+        #
+        # @param slug [String] Worktree slug
+        # @return [Boolean]
+        def exists?(slug)
+          !find_by_slug(slug).nil?
+        end
+
+        # List all worktrees
+        #
+        # @param type [String, nil] Filter by type (standard, pr)
+        # @return [Array<Hash>] Worktrees
+        def list(type: nil)
+          rows = if type
+            query(
+              "SELECT * FROM worktrees WHERE project_dir = ? AND worktree_type = ? ORDER BY created_at DESC",
+              [project_dir, type]
+            )
+          else
+            query(
+              "SELECT * FROM worktrees WHERE project_dir = ? ORDER BY created_at DESC",
+              [project_dir]
+            )
+          end
+
+          rows.map { |row| deserialize_worktree(row) }
+        end
+
+        # List standard worktrees (for Worktree module)
+        #
+        # @return [Array<Hash>]
+        def list_standard
+          list(type: "standard")
+        end
+
+        # List PR worktrees (for PRWorktreeManager)
+        #
+        # @return [Hash] Map of pr_number => worktree info
+        def list_pr_worktrees
+          rows = query(
+            "SELECT * FROM worktrees WHERE project_dir = ? AND worktree_type = 'pr'",
+            [project_dir]
+          )
+
+          rows.each_with_object({}) do |row, hash|
+            wt = deserialize_worktree(row)
+            hash[wt[:pr_number].to_s] = wt if wt[:pr_number]
+          end
+        end
+
+        # Unregister a worktree by slug
+        #
+        # @param slug [String] Worktree slug
+        def unregister(slug)
+          execute(
+            "DELETE FROM worktrees WHERE project_dir = ? AND slug = ?",
+            [project_dir, slug]
+          )
+          Aidp.log_debug("worktree_repository", "unregistered", slug: slug)
+        end
+
+        # Unregister a PR worktree
+        #
+        # @param pr_number [Integer] PR number
+        def unregister_pr(pr_number)
+          execute(
+            "DELETE FROM worktrees WHERE project_dir = ? AND pr_number = ?",
+            [project_dir, pr_number]
+          )
+          Aidp.log_debug("worktree_repository", "unregistered_pr", pr_number: pr_number)
+        end
+
+        # Update worktree status
+        #
+        # @param slug [String] Worktree slug
+        # @param status [String] New status
+        def update_status(slug, status)
+          execute(
+            "UPDATE worktrees SET status = ?, updated_at = ? WHERE project_dir = ? AND slug = ?",
+            [status, current_timestamp, project_dir, slug]
+          )
+        end
+
+        # Cleanup stale PR worktrees
+        #
+        # @param days_threshold [Integer] Days after which to consider stale
+        # @return [Array<Hash>] Removed worktrees
+        def cleanup_stale_pr(days_threshold: 30)
+          threshold_time = (Time.now - (days_threshold * 24 * 60 * 60)).strftime("%Y-%m-%d %H:%M:%S")
+
+          stale = query(
+            "SELECT * FROM worktrees WHERE project_dir = ? AND worktree_type = 'pr' AND created_at < ?",
+            [project_dir, threshold_time]
+          )
+
+          stale.each do |row|
+            execute("DELETE FROM worktrees WHERE id = ?", [row["id"]])
+          end
+
+          stale.map { |row| deserialize_worktree(row) }
+        end
+
+        private
+
+        def deserialize_worktree(row)
+          return nil unless row
+
+          metadata = deserialize_json(row["metadata"]) || {}
+
+          {
+            id: row["id"],
+            slug: row["slug"],
+            path: row["path"],
+            branch: row["branch"],
+            worktree_type: row["worktree_type"],
+            pr_number: row["pr_number"],
+            status: row["status"],
+            metadata: metadata,
+            base_branch: metadata[:base_branch],
+            head_branch: metadata[:head_branch] || row["branch"],
+            created_at: row["created_at"],
+            updated_at: row["updated_at"],
+            active: row["path"] && Dir.exist?(row["path"])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/repository.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Aidp
+  module Database
+    # Base repository class for database access
+    # Provides common patterns for CRUD operations
+    class Repository
+      attr_reader :project_dir, :table_name
+
+      # @param table_name [String] Database table name
+      # @param project_dir [String] Project directory path
+      def initialize(table_name:, project_dir: Dir.pwd)
+        @project_dir = project_dir
+        @table_name = table_name
+      end
+
+      protected
+
+      # Get database connection
+      def db
+        Database.connection(project_dir)
+      end
+
+      # Execute a query and return all results
+      #
+      # @param sql [String] SQL query
+      # @param params [Array] Query parameters
+      # @return [Array<Hash>] Query results
+      def query(sql, params = [])
+        db.execute(sql, params)
+      end
+
+      # Execute a query and return first result
+      #
+      # @param sql [String] SQL query
+      # @param params [Array] Query parameters
+      # @return [Hash, nil] First result or nil
+      def query_one(sql, params = [])
+        db.execute(sql, params).first
+      end
+
+      # Execute a query and return single value
+      #
+      # @param sql [String] SQL query
+      # @param params [Array] Query parameters
+      # @return [Object, nil] Single value or nil
+      def query_value(sql, params = [])
+        db.get_first_value(sql, params)
+      end
+
+      # Execute a statement (INSERT, UPDATE, DELETE)
+      #
+      # @param sql [String] SQL statement
+      # @param params [Array] Statement parameters
+      def execute(sql, params = [])
+        db.execute(sql, params)
+      end
+
+      # Execute within a transaction
+      #
+      # @yield Block to execute in transaction
+      # @return [Object] Block result
+      def transaction(&block)
+        db.transaction(&block)
+      end
+
+      # Get the last inserted row ID
+      #
+      # @return [Integer] Last row ID
+      def last_insert_row_id
+        db.last_insert_row_id
+      end
+
+      # Serialize a value to JSON for storage
+      #
+      # @param value [Object] Value to serialize
+      # @return [String, nil] JSON string or nil
+      def serialize_json(value)
+        return nil if value.nil?
+
+        JSON.generate(value)
+      end
+
+      # Deserialize a JSON string from storage
+      #
+      # @param json_string [String, nil] JSON string
+      # @return [Object, nil] Deserialized value or nil
+      def deserialize_json(json_string)
+        return nil if json_string.nil? || json_string.empty?
+
+        JSON.parse(json_string, symbolize_names: true)
+      rescue JSON::ParserError => e
+        Aidp.log_debug("repository", "json_parse_error",
+          table: table_name,
+          error: e.message)
+        nil
+      end
+
+      # Generate current timestamp in SQLite format
+      #
+      # @return [String] ISO 8601 timestamp
+      def current_timestamp
+        Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+      end
+
+      # Build a simple INSERT statement
+      #
+      # @param columns [Array<Symbol>] Column names
+      # @return [String] INSERT SQL
+      def insert_sql(columns)
+        placeholders = columns.map { "?" }.join(", ")
+        cols = columns.join(", ")
+        "INSERT INTO #{table_name} (#{cols}) VALUES (#{placeholders})"
+      end
+
+      # Build a simple UPDATE statement
+      #
+      # @param columns [Array<Symbol>] Column names to update
+      # @param where_column [Symbol] WHERE clause column
+      # @return [String] UPDATE SQL
+      def update_sql(columns, where_column: :id)
+        set_clause = columns.map { |c| "#{c} = ?" }.join(", ")
+        "UPDATE #{table_name} SET #{set_clause} WHERE #{where_column} = ?"
+      end
+
+      # Find a record by ID
+      #
+      # @param id [Object] Record ID
+      # @return [Hash, nil] Record or nil
+      def find_by_id(id)
+        query_one("SELECT * FROM #{table_name} WHERE id = ?", [id])
+      end
+
+      # Find all records matching project_dir
+      #
+      # @return [Array<Hash>] Records
+      def find_by_project
+        query("SELECT * FROM #{table_name} WHERE project_dir = ?", [project_dir])
+      end
+
+      # Delete a record by ID
+      #
+      # @param id [Object] Record ID
+      def delete_by_id(id)
+        execute("DELETE FROM #{table_name} WHERE id = ?", [id])
+      end
+
+      # Delete all records matching project_dir
+      def delete_by_project
+        execute("DELETE FROM #{table_name} WHERE project_dir = ?", [project_dir])
+      end
+
+      # Count records matching project_dir
+      #
+      # @return [Integer] Record count
+      def count_by_project
+        query_value(
+          "SELECT COUNT(*) FROM #{table_name} WHERE project_dir = ?",
+          [project_dir]
+        ) || 0
+      end
+    end
+  end
+end