aidp 0.1.0

data/lib/aidp/execute/progress.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "time"
+
+module Aidp
+  module Execute
+    # Manages progress tracking for execute mode, isolated from analyze mode
+    class Progress
+      attr_reader :project_dir, :progress_file
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+        @progress_file = File.join(project_dir, ".aidp-progress.yml")
+        load_progress
+      end
+
+      def completed_steps
+        @progress["completed_steps"] || []
+      end
+
+      def current_step
+        @progress["current_step"]
+      end
+
+      def started_at
+        @progress["started_at"] ? Time.parse(@progress["started_at"]) : nil
+      end
+
+      def step_completed?(step_name)
+        completed_steps.include?(step_name)
+      end
+
+      def mark_step_completed(step_name)
+        @progress["completed_steps"] ||= []
+        @progress["completed_steps"] << step_name unless step_completed?(step_name)
+        @progress["current_step"] = nil
+        @progress["started_at"] ||= Time.now.iso8601
+        save_progress
+      end
+
+      def mark_step_in_progress(step_name)
+        @progress["current_step"] = step_name
+        @progress["started_at"] ||= Time.now.iso8601
+        save_progress
+      end
+
+      def reset
+        @progress = {
+          "completed_steps" => [],
+          "current_step" => nil,
+          "started_at" => nil
+        }
+        save_progress
+      end
+
+      def next_step
+        Aidp::Execute::Steps::SPEC.keys.find { |step| !step_completed?(step) }
+      end
+
+      private
+
+      def load_progress
+        @progress = if File.exist?(@progress_file)
+          YAML.load_file(@progress_file) || {}
+        else
+          {}
+        end
+      end
+
+      def save_progress
+        File.write(@progress_file, @progress.to_yaml)
+      end
+    end
+  end
+end

data/lib/aidp/execute/runner.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "erb"
+require "yaml"
+require "json"
+
+module Aidp
+  module Execute
+    # Handles execution logic for execute mode steps
+    class Runner
+      attr_reader :project_dir, :progress
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+        @progress = Aidp::Execute::Progress.new(project_dir)
+      end
+
+      def run_step(step_name, options = {})
+        raise "Step '#{step_name}' not found in execute mode steps" unless Aidp::Execute::Steps::SPEC.key?(step_name)
+
+        step_spec = Aidp::Execute::Steps::SPEC[step_name]
+        template_name = step_spec["templates"].first
+
+        # Load template
+        template = find_template(template_name)
+        raise "Template '#{template_name}' not found" unless template
+
+        # Compose prompt
+        prompt = composed_prompt(template_name, options)
+
+        # Handle error simulation for tests
+        if options[:simulate_error]
+          return {
+            status: "error",
+            error: options[:simulate_error],
+            step: step_name
+          }
+        end
+
+        # Execute step (mock for now)
+        result = {
+          status: "success",
+          step: step_name,
+          output_files: step_spec["outs"],
+          prompt: prompt
+        }
+
+        # Mark step as completed
+        @progress.mark_step_completed(step_name)
+
+        # Generate output files
+        generate_output_files(step_name, step_spec["outs"], result)
+
+        # Generate database export
+        generate_database_export
+
+        result
+      end
+
+      private
+
+      def find_template(template_name)
+        template_search_paths.each do |path|
+          template_file = File.join(path, template_name)
+          return File.read(template_file) if File.exist?(template_file)
+        end
+        nil
+      end
+
+      def template_search_paths
+        [
+          File.join(@project_dir, "templates"),
+          File.join(@project_dir, "templates", "COMMON"),
+          File.join(File.dirname(__FILE__), "..", "..", "..", "templates", "EXECUTE"),
+          File.join(File.dirname(__FILE__), "..", "..", "..", "templates", "COMMON")
+        ]
+      end
+
+      def composed_prompt(template_name, options = {})
+        template = find_template(template_name)
+        return template unless template
+
+        # Load agent base template if available
+        agent_base = find_template("AGENT_BASE.md")
+        template = "#{agent_base}\n\n#{template}" if agent_base
+
+        # Replace placeholders
+        options.each do |key, value|
+          template = template.gsub("{{#{key}}}", value.to_s)
+        end
+
+        template
+      end
+
+      def generate_output_files(step_name, output_files, result)
+        output_files.each do |output_file|
+          file_path = File.join(@project_dir, output_file)
+          content = generate_output_content(step_name, output_file, result)
+          File.write(file_path, content)
+        end
+      end
+
+      def generate_output_content(step_name, output_file, result)
+        case output_file
+        when /\.md$/
+          "# #{step_name} Output\n\nGenerated on #{Time.now}\n\n## Result\n\n#{result[:status]}"
+        when /\.json$/
+          result.to_json
+        else
+          "Output for #{step_name}: #{result[:status]}"
+        end
+      end
+
+      def generate_database_export
+        database_file = File.join(@project_dir, ".aidp.db")
+        require "sqlite3"
+
+        begin
+          db = SQLite3::Database.new(database_file)
+          db.execute("CREATE TABLE IF NOT EXISTS execute_results (step TEXT, status TEXT, completed_at TEXT)")
+
+          Aidp::Execute::Steps::SPEC.keys.each do |step|
+            if @progress.step_completed?(step)
+              db.execute("INSERT INTO execute_results (step, status, completed_at) VALUES (?, ?, ?)",
+                [step, "success", Time.now.iso8601])
+            end
+          end
+        rescue => e
+          # Log the error but don't fail the execution
+          puts "Warning: Database export failed: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/aidp/execute/steps.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Execute
+    # Defines the steps, templates, outputs, and associated AI agents for execute mode
+    class Steps
+      SPEC = {
+        "00_PRD" => {
+          "templates" => ["00_PRD.md"],
+          "outs" => ["00_PRD.md"],
+          "gate" => false,
+          "agent" => "Product Manager"
+        },
+        "01_NFRS" => {
+          "templates" => ["01_NFRS.md"],
+          "outs" => ["01_NFRS.md"],
+          "gate" => false,
+          "agent" => "Architect"
+        },
+        "02_ARCHITECTURE" => {
+          "templates" => ["02_ARCHITECTURE.md"],
+          "outs" => ["02_ARCHITECTURE.md"],
+          "gate" => false,
+          "agent" => "Architect"
+        },
+        "02A_ARCH_GATE_QUESTIONS" => {
+          "templates" => ["02A_ARCH_GATE_QUESTIONS.md"],
+          "outs" => ["02A_ARCH_GATE_QUESTIONS.md"],
+          "gate" => true,
+          "agent" => "Architect"
+        },
+        "03_ADR_FACTORY" => {
+          "templates" => ["03_ADR_FACTORY.md"],
+          "outs" => ["03_ADR_FACTORY.md"],
+          "gate" => false,
+          "agent" => "Architect"
+        },
+        "04_DOMAIN_DECOMPOSITION" => {
+          "templates" => ["04_DOMAIN_DECOMPOSITION.md"],
+          "outs" => ["04_DOMAIN_DECOMPOSITION.md"],
+          "gate" => false,
+          "agent" => "Architect"
+        },
+        "05_CONTRACTS" => {
+          "templates" => ["05_CONTRACTS.md"],
+          "outs" => ["05_CONTRACTS.md"],
+          "gate" => false,
+          "agent" => "Architect"
+        },
+        "06_THREAT_MODEL" => {
+          "templates" => ["06_THREAT_MODEL.md"],
+          "outs" => ["06_THREAT_MODEL.md"],
+          "gate" => false,
+          "agent" => "Security Expert"
+        },
+        "07_TEST_PLAN" => {
+          "templates" => ["07_TEST_PLAN.md"],
+          "outs" => ["07_TEST_PLAN.md"],
+          "gate" => false,
+          "agent" => "Test Engineer"
+        },
+        "08_TASKS" => {
+          "templates" => ["08_TASKS.md"],
+          "outs" => ["08_TASKS.md"],
+          "gate" => false,
+          "agent" => "Project Manager"
+        },
+        "09_SCAFFOLDING_DEVEX" => {
+          "templates" => ["09_SCAFFOLDING_DEVEX.md"],
+          "outs" => ["09_SCAFFOLDING_DEVEX.md"],
+          "gate" => false,
+          "agent" => "DevOps Engineer"
+        },
+        "10_IMPLEMENTATION_AGENT" => {
+          "templates" => ["10_IMPLEMENTATION_AGENT.md"],
+          "outs" => ["10_IMPLEMENTATION_AGENT.md"],
+          "gate" => false,
+          "agent" => "Implementation Specialist"
+        },
+        "11_STATIC_ANALYSIS" => {
+          "templates" => ["11_STATIC_ANALYSIS.md"],
+          "outs" => ["11_STATIC_ANALYSIS.md"],
+          "gate" => false,
+          "agent" => "Code Quality Expert"
+        },
+        "12_OBSERVABILITY_SLOS" => {
+          "templates" => ["12_OBSERVABILITY_SLOS.md"],
+          "outs" => ["12_OBSERVABILITY_SLOS.md"],
+          "gate" => false,
+          "agent" => "SRE Engineer"
+        },
+        "13_DELIVERY_ROLLOUT" => {
+          "templates" => ["13_DELIVERY_ROLLOUT.md"],
+          "outs" => ["13_DELIVERY_ROLLOUT.md"],
+          "gate" => false,
+          "agent" => "DevOps Engineer"
+        },
+        "14_DOCS_PORTAL" => {
+          "templates" => ["14_DOCS_PORTAL.md"],
+          "outs" => ["14_DOCS_PORTAL.md"],
+          "gate" => false,
+          "agent" => "Technical Writer"
+        },
+        "15_POST_RELEASE" => {
+          "templates" => ["15_POST_RELEASE.md"],
+          "outs" => ["15_POST_RELEASE.md"],
+          "gate" => false,
+          "agent" => "Project Manager"
+        }
+      }.freeze
+    end
+  end
+end

data/lib/aidp/shared/cli.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Aidp
+  module Shared
+    # CLI interface for both execute and analyze modes
+    class CLI < Thor
+      desc "execute [STEP]", "Run execute mode step(s)"
+      option :force, type: :boolean, desc: "Force execution even if dependencies are not met"
+      option :rerun, type: :boolean, desc: "Re-run a completed step"
+      def execute(project_dir = Dir.pwd, step_name = nil, custom_options = {})
+        if step_name
+          runner = Aidp::Execute::Runner.new(project_dir)
+          # Merge Thor options with custom options
+          all_options = options.merge(custom_options)
+          runner.run_step(step_name, all_options)
+        else
+          puts "Available execute steps:"
+          Aidp::Execute::Steps::SPEC.keys.each { |step| puts "  - #{step}" }
+          progress = Aidp::Execute::Progress.new(project_dir)
+          next_step = progress.next_step
+          {status: "success", message: "Available steps listed", next_step: next_step}
+        end
+      end
+
+      desc "analyze [STEP]", "Run analyze mode step(s)"
+      option :force, type: :boolean, desc: "Force execution even if dependencies are not met"
+      option :rerun, type: :boolean, desc: "Re-run a completed step"
+      def analyze(project_dir = Dir.pwd, step_name = nil, custom_options = {})
+        if step_name
+          runner = Aidp::Analyze::Runner.new(project_dir)
+          # Merge Thor options with custom options
+          all_options = options.merge(custom_options)
+          runner.run_step(step_name, all_options)
+        else
+          puts "Available analyze steps:"
+          Aidp::Analyze::Steps::SPEC.keys.each { |step| puts "  - #{step}" }
+          progress = Aidp::Analyze::Progress.new(project_dir)
+          next_step = progress.next_step
+          {status: "success", message: "Available steps listed", next_step: next_step,
+           completed_steps: progress.completed_steps}
+        end
+      end
+
+      desc "analyze-approve STEP", "Approve a completed analyze gate step"
+      def analyze_approve(project_dir = Dir.pwd, step_name = nil)
+        progress = Aidp::Analyze::Progress.new(project_dir)
+        progress.mark_step_completed(step_name)
+        puts "✅ Approved analyze step: #{step_name}"
+        {status: "success", step: step_name}
+      end
+
+      desc "analyze-reset", "Reset analyze mode progress"
+      def analyze_reset(project_dir = Dir.pwd)
+        progress = Aidp::Analyze::Progress.new(project_dir)
+        progress.reset
+        puts "🔄 Reset analyze mode progress"
+        {status: "success", message: "Progress reset"}
+      end
+
+      desc "execute-approve STEP", "Approve a completed execute gate step"
+      def execute_approve(project_dir = Dir.pwd, step_name = nil)
+        progress = Aidp::Execute::Progress.new(project_dir)
+        progress.mark_step_completed(step_name)
+        puts "✅ Approved execute step: #{step_name}"
+        {status: "success", step: step_name}
+      end
+
+      desc "execute-reset", "Reset execute mode progress"
+      def execute_reset(project_dir = Dir.pwd)
+        progress = Aidp::Execute::Progress.new(project_dir)
+        progress.reset
+        puts "🔄 Reset execute mode progress"
+        {status: "success", message: "Progress reset"}
+      end
+
+      # Backward compatibility aliases
+      desc "approve STEP", "Approve a completed execute gate step (alias for execute-approve)"
+      def approve(project_dir = Dir.pwd, step_name = nil)
+        execute_approve(project_dir, step_name)
+      end
+
+      desc "reset", "Reset execute mode progress (alias for execute-reset)"
+      def reset(project_dir = Dir.pwd)
+        execute_reset(project_dir)
+      end
+
+      desc "status", "Show current progress for both modes"
+      def status
+        puts "\n📊 AI Dev Pipeline Status"
+        puts "=" * 50
+
+        # Execute mode status
+        execute_progress = Aidp::Execute::Progress.new(Dir.pwd)
+        puts "\n🔧 Execute Mode:"
+        Aidp::Execute::Steps::SPEC.keys.each do |step|
+          status = execute_progress.step_completed?(step) ? "✅" : "⏳"
+          puts "  #{status} #{step}"
+        end
+
+        # Analyze mode status
+        analyze_progress = Aidp::Analyze::Progress.new(Dir.pwd)
+        puts "\n🔍 Analyze Mode:"
+        Aidp::Analyze::Steps::SPEC.keys.each do |step|
+          status = analyze_progress.step_completed?(step) ? "✅" : "⏳"
+          puts "  #{status} #{step}"
+        end
+      end
+
+      desc "version", "Show version information"
+      def version
+        puts "Aidp version #{Aidp::Shared::VERSION}"
+      end
+    end
+  end
+end

data/lib/aidp/shared/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Aidp
+  module Shared
+    # Configuration management for both execute and analyze modes
+    class Config
+      def self.load(project_dir = Dir.pwd)
+        config_file = File.join(project_dir, ".aidp.yml")
+        if File.exist?(config_file)
+          YAML.load_file(config_file) || {}
+        else
+          {}
+        end
+      end
+
+      def self.templates_root
+        File.join(Dir.pwd, "templates")
+      end
+
+      def self.analyze_templates_root
+        File.join(Dir.pwd, "templates", "ANALYZE")
+      end
+
+      def self.execute_templates_root
+        File.join(Dir.pwd, "templates", "EXECUTE")
+      end
+
+      def self.common_templates_root
+        File.join(Dir.pwd, "templates", "COMMON")
+      end
+    end
+  end
+end

data/lib/aidp/shared/project_detector.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Aidp
+  module Shared
+    # Detects project type, language, framework, and other characteristics
+    class ProjectDetector
+      attr_reader :project_dir
+
+      def initialize(project_dir = Dir.pwd)
+        @project_dir = project_dir
+      end
+
+      def detect
+        {
+          language: detect_language,
+          framework: detect_framework,
+          build_system: detect_build_system,
+          package_manager: detect_package_manager,
+          static_analysis_tools: detect_static_analysis_tools,
+          test_framework: detect_test_framework,
+          database: detect_database,
+          deployment: detect_deployment
+        }
+      end
+
+      private
+
+      def detect_language
+        return "ruby" if File.exist?(File.join(@project_dir, "Gemfile"))
+        return "javascript" if File.exist?(File.join(@project_dir, "package.json"))
+        return "python" if File.exist?(File.join(@project_dir, "requirements.txt")) || File.exist?(File.join(@project_dir, "pyproject.toml"))
+        return "java" if File.exist?(File.join(@project_dir, "pom.xml")) || File.exist?(File.join(@project_dir, "build.gradle"))
+        return "go" if File.exist?(File.join(@project_dir, "go.mod"))
+        return "rust" if File.exist?(File.join(@project_dir, "Cargo.toml"))
+        return "csharp" if File.exist?(File.join(@project_dir, "*.csproj"))
+        "unknown"
+      end
+
+      def detect_framework
+        case detect_language
+        when "ruby"
+          return "rails" if File.exist?(File.join(@project_dir, "config", "application.rb"))
+          return "sinatra" if File.exist?(File.join(@project_dir, "app.rb")) && File.read(File.join(@project_dir, "app.rb")).include?("Sinatra")
+        when "javascript"
+          return "react" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("react")
+          return "vue" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("vue")
+          return "angular" if File.exist?(File.join(@project_dir, "angular.json"))
+          return "express" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("express")
+        when "python"
+          return "django" if File.exist?(File.join(@project_dir, "manage.py"))
+          return "flask" if File.exist?(File.join(@project_dir, "app.py")) && File.read(File.join(@project_dir, "app.py")).include?("Flask")
+        when "java"
+          return "spring" if File.exist?(File.join(@project_dir, "pom.xml")) && File.read(File.join(@project_dir, "pom.xml")).include?("spring-boot")
+        end
+        "unknown"
+      end
+
+      def detect_build_system
+        return "maven" if File.exist?(File.join(@project_dir, "pom.xml"))
+        return "gradle" if File.exist?(File.join(@project_dir, "build.gradle"))
+        return "npm" if File.exist?(File.join(@project_dir, "package.json"))
+        return "bundler" if File.exist?(File.join(@project_dir, "Gemfile"))
+        return "pip" if File.exist?(File.join(@project_dir, "requirements.txt"))
+        return "cargo" if File.exist?(File.join(@project_dir, "Cargo.toml"))
+        return "go" if File.exist?(File.join(@project_dir, "go.mod"))
+        "unknown"
+      end
+
+      def detect_package_manager
+        detect_build_system
+      end
+
+      def detect_static_analysis_tools
+        tools = []
+        tools << "rubocop" if File.exist?(File.join(@project_dir, ".rubocop.yml"))
+        tools << "eslint" if File.exist?(File.join(@project_dir, ".eslintrc"))
+        tools << "flake8" if File.exist?(File.join(@project_dir, ".flake8"))
+        tools << "checkstyle" if File.exist?(File.join(@project_dir, "checkstyle.xml"))
+        tools << "clippy" if File.exist?(File.join(@project_dir, "Cargo.toml"))
+        tools
+      end
+
+      def detect_test_framework
+        case detect_language
+        when "ruby"
+          return "rspec" if File.exist?(File.join(@project_dir, "spec"))
+          return "minitest" if File.exist?(File.join(@project_dir, "test"))
+        when "javascript"
+          return "jest" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("jest")
+          return "mocha" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("mocha")
+        when "python"
+          return "pytest" if File.exist?(File.join(@project_dir, "pytest.ini"))
+          return "unittest" if Dir.exist?(File.join(@project_dir, "tests"))
+        when "java"
+          return "junit" if File.exist?(File.join(@project_dir, "src", "test"))
+        end
+        "unknown"
+      end
+
+      def detect_database
+        return "postgresql" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("postgresql")
+        return "mysql" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("mysql")
+        return "sqlite" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("sqlite")
+        "unknown"
+      end
+
+      def detect_deployment
+        return "docker" if File.exist?(File.join(@project_dir, "Dockerfile"))
+        return "kubernetes" if File.exist?(File.join(@project_dir, "k8s")) || File.exist?(File.join(@project_dir, "kubernetes"))
+        return "heroku" if File.exist?(File.join(@project_dir, "Procfile"))
+        return "aws" if File.exist?(File.join(@project_dir, "serverless.yml")) || File.exist?(File.join(@project_dir, "template.yaml"))
+        "unknown"
+      end
+    end
+  end
+end

data/lib/aidp/shared/providers/anthropic.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Aidp
+  module Shared
+    module Providers
+      class Anthropic < Base
+        def self.available?
+          !!Aidp::Shared::Util.which("claude")
+        end
+
+        def name = "anthropic"
+
+        def send(prompt:, session: nil)
+          raise "claude CLI not available" unless self.class.available?
+
+          # Use Claude CLI for non-interactive mode
+          cmd = ["claude", "compose", "--prompt", prompt]
+          system(*cmd)
+          :ok
+        end
+      end
+    end
+  end
+end

data/lib/aidp/shared/providers/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Shared
+    module Providers
+      class Base
+        def name = raise(NotImplementedError)
+
+        # Send a composed prompt string to the provider.
+        # Return :ok when command completed successfully,
+        # Return :interactive when starting an interactive session (for gate steps),
+        # or return a string if we captured output and the caller should write to a file.
+        def send(prompt:, session: nil) = raise(NotImplementedError)
+      end
+    end
+  end
+end