aidp 0.47.1 → 0.49.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 687e2dc3dc54edf4fcdabb7ca75462595d51f0d8a1f3ad09d1954d035f576b05
-  data.tar.gz: '089d63153f9a059188ce59385882d3920b32fbb40d4be644bbc877eade2263b6'
+  metadata.gz: 0c5a91840d333d7b33122434b8cc2efcad0149becf640e3932d5d1ea6fd799f1
+  data.tar.gz: 0604c7d3798c6dc90aa1ccf543916e73e63fabdd4bcc58ae1a0864cbb0277a0a
 SHA512:
-  metadata.gz: bd7626bbf6245b7f02748abb9761423a4d7e64fc81983ca35bf7ecd14a15b3c6916ac80085e7df5c1dc6861e007cfb372bacf67bef6fb670bd73de5b206655b9
-  data.tar.gz: 8ef9d9a2dbd220408a45d3d7f4d3bf96b07445d24a5a05867a4c6094a4e0425f69c7f033e42966d73d35ab207d2f157fc781163196ba2c837f4ddc7ad5149371
+  metadata.gz: 8dbaefb32e45cd9687524dea4cd72dc4c38eb13bb766f7e5b476e67481338ad76e6b6c72c0a80cd1e479487701266036c8d1b8cbab74ae288ff44ccaa5d891ac
+  data.tar.gz: b2de14911ec9b019235a4966d74208a61d5e2970a9fd710b31d0b58d2ec6f741bbdd6eb0a8314a6fbc7916bbd3c24c6352efa577080d356001dbd583b4aed6f3

data/lib/aidp/cli/devcontainer_commands.rb

@@ -280,13 +280,45 @@ module Aidp
         # Extract wizard-compatible config including custom_ports
         {
           providers: aidp_config.dig("providers")&.keys,
-          test_framework: aidp_config.dig("work_loop", "test_commands", 0, "framework"),
+          test_framework: extract_test_framework_for_generation(aidp_config),
           linters: aidp_config.dig("work_loop", "linting", "tools"),
           watch_mode: aidp_config.dig("work_loop", "watch", "enabled"),
           custom_ports: aidp_config.dig("devcontainer", "custom_ports")
         }.compact
       end
 
+      def extract_test_framework_for_generation(aidp_config)
+        framework_from_work_loop_commands(aidp_config) ||
+          aidp_config.dig("work_loop", "test_commands", 0, "framework")
+      end
+
+      def framework_from_work_loop_commands(aidp_config)
+        candidates = Array(aidp_config.dig("work_loop", "commands"))
+        command_text = tagged_test_command(candidates) || first_recognized_string_command(candidates)
+        framework = Aidp::ToolingDetector.framework_from_command(command_text)
+        return if framework == :unknown
+
+        framework.to_s
+      end
+
+      # `work_loop.commands` entries may be hashes with a category, or bare
+      # command strings (no category available). Prefer an explicitly tagged
+      # test command; when only bare strings are present, fall back to the
+      # first one whose command text matches a known test framework.
+      def tagged_test_command(candidates)
+        candidates.find do |candidate|
+          candidate.is_a?(Hash) &&
+            # `generate_yaml` writes category as a symbol (e.g. `:test`); YAML
+            # preserves symbols on load, so coerce to string before comparing.
+            candidate["category"].to_s == "test"
+        end&.dig("command")
+      end
+
+      def first_recognized_string_command(candidates)
+        candidates.select { |candidate| candidate.is_a?(String) }
+          .find { |command| Aidp::ToolingDetector.framework_from_command(command) != :unknown }
+      end
+
       def build_config_from_aidp_yml(devcontainer_config)
         config = {}
 

data/lib/aidp/cli/temporal_command.rb

@@ -3,6 +3,8 @@
 require "tty-prompt"
 require "tty-table"
 require "pastel"
+require_relative "../strategy_execution/strategy_loader"
+require_relative "../strategy_execution/experience_store"
 require_relative "terminal_io"
 
 module Aidp
@@ -30,6 +32,10 @@ module Aidp
         case subcommand
         when "start", nil
           start_workflow(args)
+        when "replay"
+          replay_workflow(args)
+        when "benchmark"
+          benchmark_workflows(args)
         when "list"
           list_workflows(args)
         when "status"
@@ -61,6 +67,9 @@ module Aidp
         display_message("")
         display_message("Temporal Workflow Commands:", type: :info)
         display_message("  aidp temporal start [issue_number]  - Start issue-to-PR workflow", type: :info)
+        display_message("  aidp temporal start strategy <strategy.yml> [task.json] - Start strategy workflow", type: :info)
+        display_message("  aidp temporal replay <run_id> <strategy.yml> - Replay a task with a new strategy", type: :info)
+        display_message("  aidp temporal benchmark <strategy.yml> <run_id> [run_id...] - Replay many runs", type: :info)
         display_message("  aidp temporal list                  - List active workflows", type: :info)
         display_message("  aidp temporal status <workflow_id>  - Show workflow status", type: :info)
         display_message("  aidp temporal signal <workflow_id> <signal> - Send signal to workflow", type: :info)
@@ -80,9 +89,11 @@ module Aidp
           start_issue_to_pr_workflow(issue_number)
         when "workloop", "work_loop"
           start_work_loop_workflow(args)
+        when "strategy"
+          start_strategy_workflow(args)
         else
           display_message("Unknown workflow type: #{workflow_type}", type: :error)
-          display_message("Available: issue, workloop", type: :info)
+          display_message("Available: issue, workloop, strategy", type: :info)
         end
       end
 
@@ -90,6 +101,7 @@ module Aidp
         @prompt.select("Select workflow type:") do |menu|
           menu.choice "Issue to PR (full pipeline)", "issue"
           menu.choice "Work Loop (fix-forward iteration)", "workloop"
+          menu.choice "Strategy Execution", "strategy"
         end
       end
 
@@ -144,6 +156,92 @@ module Aidp
         display_message("Monitor with: aidp temporal status #{handle.id}", type: :info)
       end
 
+      def start_strategy_workflow(args)
+        strategy_path = args.shift
+        task_path = args.shift
+
+        unless strategy_path
+          display_message("Usage: aidp temporal start strategy <strategy.yml> [task.json]", type: :error)
+          return
+        end
+
+        strategy = load_strategy(strategy_path)
+        task = task_path ? load_task(task_path) : prompt_for_task
+
+        handle = Aidp::Temporal.start_workflow(
+          Aidp::Temporal::Workflows::StrategyExecutionWorkflow,
+          {
+            project_dir: @project_dir,
+            strategy: strategy.to_h,
+            task: task
+          },
+          project_dir: @project_dir
+        )
+
+        display_message("Started strategy workflow #{strategy.name}", type: :success)
+        display_message("  Workflow ID: #{handle.id}", type: :info)
+      end
+
+      def replay_workflow(args)
+        original_run_id = args.shift
+        strategy_path = args.shift
+
+        unless original_run_id && strategy_path
+          display_message("Usage: aidp temporal replay <run_id> <strategy.yml>", type: :error)
+          return
+        end
+
+        bundle = experience_store.replay_bundle(original_run_id)
+        unless bundle
+          display_message("Replay source run not found: #{original_run_id}", type: :error)
+          return
+        end
+
+        strategy = load_strategy(strategy_path)
+        replay_task = build_replay_task(bundle[:task], original_run_id)
+
+        handle = Aidp::Temporal.start_workflow(
+          Aidp::Temporal::Workflows::StrategyExecutionWorkflow,
+          {
+            project_dir: @project_dir,
+            strategy: strategy.to_h,
+            task: replay_task
+          },
+          project_dir: @project_dir
+        )
+
+        display_message("Replay started from run #{original_run_id}", type: :success)
+        display_message("  Workflow ID: #{handle.id}", type: :info)
+      end
+
+      def benchmark_workflows(args)
+        strategy_path = args.shift
+        run_ids = args
+
+        unless strategy_path && run_ids.any?
+          display_message("Usage: aidp temporal benchmark <strategy.yml> <run_id> [run_id...]", type: :error)
+          return
+        end
+
+        strategy = load_strategy(strategy_path)
+        started = run_ids.filter_map do |run_id|
+          bundle = experience_store.replay_bundle(run_id)
+          next unless bundle
+
+          Aidp::Temporal.start_workflow(
+            Aidp::Temporal::Workflows::StrategyExecutionWorkflow,
+            {
+              project_dir: @project_dir,
+              strategy: strategy.to_h,
+              task: build_replay_task(bundle[:task], run_id)
+            },
+            project_dir: @project_dir
+          ).id
+        end
+
+        display_message("Started #{started.length} benchmark replay workflow(s)", type: :success)
+      end
+
       def list_workflows(args)
         require_relative "../temporal"
 
@@ -327,7 +425,9 @@ module Aidp
         worker.register_workflows(
           Aidp::Temporal::Workflows::IssueToPrWorkflow,
           Aidp::Temporal::Workflows::WorkLoopWorkflow,
-          Aidp::Temporal::Workflows::SubIssueWorkflow
+          Aidp::Temporal::Workflows::SubIssueWorkflow,
+          Aidp::Temporal::Workflows::StrategyBranchWorkflow,
+          Aidp::Temporal::Workflows::StrategyExecutionWorkflow
         )
 
         # Register all activities
@@ -342,7 +442,9 @@ module Aidp
           Aidp::Temporal::Activities::RecordCheckpointActivity.new,
           Aidp::Temporal::Activities::CreatePrActivity.new,
           Aidp::Temporal::Activities::RunWorkLoopIterationActivity.new,
-          Aidp::Temporal::Activities::AnalyzeSubTaskActivity.new
+          Aidp::Temporal::Activities::AnalyzeSubTaskActivity.new,
+          Aidp::Temporal::Activities::ExecuteCliCommandActivity.new,
+          Aidp::Temporal::Activities::ManageExperienceStoreActivity.new
         )
 
         display_message(@pastel.green("Worker started"), type: :success)
@@ -420,6 +522,33 @@ module Aidp
         display_message("  3. Start workflow: aidp temporal start issue <number>", type: :info)
       end
 
+      def load_strategy(strategy_path)
+        StrategyExecution::StrategyLoader.new(project_dir: @project_dir).load_file(strategy_path)
+      end
+
+      def build_replay_task(bundle_task, source_run_id)
+        bundle_task.except(:id, :source_run_id).merge(source_run_id: source_run_id)
+      end
+
+      def load_task(task_path)
+        JSON.parse(File.read(expand_path(task_path)), symbolize_names: true)
+      end
+
+      def prompt_for_task
+        {
+          title: @prompt.ask("Task title:"),
+          description: @prompt.ask("Task description:")
+        }
+      end
+
+      def experience_store
+        @experience_store ||= StrategyExecution::ExperienceStore.new(project_dir: @project_dir)
+      end
+
+      def expand_path(path)
+        File.expand_path(path, @project_dir)
+      end
+
       def format_status(status)
         case status.to_s
         when "running"

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class ExperienceArtifactRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "experience_artifacts")
+        end
+
+        def record(run_id:, role:, path:, metadata: {})
+          execute(
+            insert_sql([:project_dir, :run_id, :role, :path, :metadata]),
+            [project_dir, run_id, role, path, serialize_json(metadata || {})]
+          )
+
+          Aidp.log_debug("experience_artifact_repository", "recorded",
+            run_id: run_id, role: role, path: path)
+        end
+
+        def list_for_run(run_id)
+          rows = query(
+            "SELECT * FROM experience_artifacts WHERE run_id = ? AND project_dir = ? ORDER BY id ASC",
+            [run_id, project_dir]
+          )
+          rows.map do |row|
+            {
+              role: row["role"],
+              path: row["path"],
+              metadata: deserialize_json(row["metadata"]) || {},
+              created_at: row["created_at"]
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class ExperienceEvaluationRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "experience_evaluations")
+        end
+
+        def record(run_id:, evaluator_name:, score:, passed:, summary: nil, metadata: {})
+          execute(
+            insert_sql([
+              :project_dir, :run_id, :evaluator_name, :score, :passed, :summary, :metadata
+            ]),
+            [
+              project_dir,
+              run_id,
+              evaluator_name,
+              score,
+              passed ? 1 : 0,
+              summary,
+              serialize_json(metadata || {})
+            ]
+          )
+
+          Aidp.log_debug("experience_evaluation_repository", "recorded",
+            run_id: run_id,
+            evaluator_name: evaluator_name,
+            score: score,
+            passed: passed)
+        end
+
+        def list_for_run(run_id)
+          rows = query(
+            "SELECT * FROM experience_evaluations WHERE run_id = ? AND project_dir = ? ORDER BY id ASC",
+            [run_id, project_dir]
+          )
+          rows.map do |row|
+            {
+              evaluator_name: row["evaluator_name"],
+              score: row["score"],
+              passed: row["passed"] == 1,
+              summary: row["summary"],
+              metadata: deserialize_json(row["metadata"]) || {},
+              created_at: row["created_at"]
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class ExperienceRunRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "experience_runs")
+        end
+
+        def start(task_id:, strategy_id:, workflow_id:, depth:, input_payload:, parent_run_id: nil, branch_key: nil, metadata: {})
+          run_id = SecureRandom.uuid
+
+          execute(
+            insert_sql([
+              :id, :project_dir, :task_id, :strategy_id, :workflow_id, :parent_run_id,
+              :branch_key, :status, :depth, :input_payload, :metadata
+            ]),
+            [
+              run_id,
+              project_dir,
+              task_id,
+              strategy_id,
+              workflow_id,
+              parent_run_id,
+              branch_key,
+              "running",
+              depth,
+              serialize_json(input_payload || {}),
+              serialize_json(metadata || {})
+            ]
+          )
+
+          Aidp.log_debug("experience_run_repository", "started",
+            id: run_id,
+            task_id: task_id,
+            strategy_id: strategy_id,
+            branch_key: branch_key,
+            depth: depth)
+
+          load(run_id)
+        end
+
+        def complete(run_id:, status:, output_payload:, metadata: {})
+          merged_metadata = existing_metadata(run_id).merge(metadata || {})
+
+          execute(
+            <<~SQL,
+              UPDATE experience_runs
+              SET status = ?, output_payload = ?, metadata = ?, completed_at = ?
+              WHERE id = ? AND project_dir = ?
+            SQL
+            [
+              status,
+              serialize_json(output_payload || {}),
+              serialize_json(merged_metadata),
+              current_timestamp,
+              run_id,
+              project_dir
+            ]
+          )
+
+          Aidp.log_debug("experience_run_repository", "completed",
+            id: run_id, status: status)
+
+          load(run_id)
+        end
+
+        def load(run_id)
+          row = query_one(
+            "SELECT * FROM experience_runs WHERE id = ? AND project_dir = ?",
+            [run_id, project_dir]
+          )
+          deserialize_run(row)
+        end
+
+        def bundle_for_replay(run_id)
+          row = query_one(
+            <<~SQL,
+              SELECT runs.*, tasks.title AS task_title, tasks.description AS task_description,
+                     tasks.input_payload AS task_input_payload, tasks.context AS task_context,
+                     tasks.source_run_id AS task_source_run_id
+              FROM experience_runs runs
+              JOIN experience_tasks tasks ON tasks.id = runs.task_id
+              WHERE runs.id = ? AND runs.project_dir = ?
+            SQL
+            [run_id, project_dir]
+          )
+          return nil unless row
+
+          run = deserialize_run(row)
+          run.merge(
+            task: {
+              id: row["task_id"],
+              title: row["task_title"],
+              description: row["task_description"],
+              input_payload: deserialize_json(row["task_input_payload"]) || {},
+              context: deserialize_json(row["task_context"]) || {},
+              source_run_id: row["task_source_run_id"]
+            }
+          )
+        end
+
+        def children(parent_run_id)
+          rows = query(
+            "SELECT * FROM experience_runs WHERE parent_run_id = ? AND project_dir = ? ORDER BY started_at ASC",
+            [parent_run_id, project_dir]
+          )
+          rows.map { |row| deserialize_run(row) }
+        end
+
+        private
+
+        def existing_metadata(run_id)
+          load(run_id)&.fetch(:metadata, {}) || {}
+        end
+
+        def deserialize_run(row)
+          return nil unless row
+
+          {
+            id: row["id"],
+            task_id: row["task_id"],
+            strategy_id: row["strategy_id"],
+            workflow_id: row["workflow_id"],
+            parent_run_id: row["parent_run_id"],
+            branch_key: row["branch_key"],
+            status: row["status"],
+            depth: row["depth"],
+            input_payload: deserialize_json(row["input_payload"]) || {},
+            output_payload: deserialize_json(row["output_payload"]) || {},
+            metadata: deserialize_json(row["metadata"]) || {},
+            started_at: row["started_at"],
+            completed_at: row["completed_at"]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class ExperienceTaskRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "experience_tasks")
+        end
+
+        def create(description:, title: nil, input_payload: {}, context: {}, source_run_id: nil)
+          task_id = SecureRandom.uuid
+
+          execute(
+            insert_sql([:id, :project_dir, :title, :description, :input_payload, :context, :source_run_id]),
+            [
+              task_id,
+              project_dir,
+              title,
+              description,
+              serialize_json(input_payload || {}),
+              serialize_json(context || {}),
+              source_run_id
+            ]
+          )
+
+          Aidp.log_debug("experience_task_repository", "created",
+            id: task_id, source_run_id: source_run_id)
+
+          load(task_id)
+        end
+
+        def load(task_id)
+          row = query_one(
+            "SELECT * FROM experience_tasks WHERE id = ? AND project_dir = ?",
+            [task_id, project_dir]
+          )
+          deserialize_task(row)
+        end
+
+        private
+
+        def deserialize_task(row)
+          return nil unless row
+
+          {
+            id: row["id"],
+            title: row["title"],
+            description: row["description"],
+            input_payload: deserialize_json(row["input_payload"]) || {},
+            context: deserialize_json(row["context"]) || {},
+            source_run_id: row["source_run_id"],
+            created_at: row["created_at"]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class StrategyRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "strategies")
+        end
+
+        def register(name:, spec:)
+          strategy_id = Digest::SHA256.hexdigest("#{project_dir}:#{name}:#{spec}")
+
+          # Concurrent sibling child workflows can register the identical
+          # strategy at the same time (same deterministic strategy_id), so
+          # the insert must be idempotent rather than a check-then-insert to
+          # avoid a primary-key race between them.
+          execute(
+            "INSERT OR IGNORE INTO #{table_name} (id, project_dir, name, spec) VALUES (?, ?, ?, ?)",
+            [strategy_id, project_dir, name, spec]
+          )
+
+          Aidp.log_debug("strategy_repository", "registered", id: strategy_id, name: name)
+
+          {id: strategy_id, name: name}
+        end
+
+        def load(id)
+          row = query_one("SELECT * FROM strategies WHERE id = ? AND project_dir = ?", [id, project_dir])
+          deserialize_strategy(row)
+        end
+
+        def find_by_name(name)
+          row = query_one(
+            "SELECT * FROM strategies WHERE project_dir = ? AND name = ? ORDER BY created_at DESC, rowid DESC",
+            [project_dir, name]
+          )
+          deserialize_strategy(row)
+        end
+
+        private
+
+        def deserialize_strategy(row)
+          return nil unless row
+
+          {
+            id: row["id"],
+            name: row["name"],
+            spec: deserialize_json(row["spec"]) || {},
+            created_at: row["created_at"]
+          }
+        end
+      end
+    end
+  end
+end