aidp 0.1.0

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+require_relative "base"
+require_relative "../util"
+
+module Aidp
+  module Shared
+    module Providers
+      class Cursor < Base
+        def self.available?
+          !!Aidp::Shared::Util.which("cursor-agent")
+        end
+
+        def name = "cursor"
+
+        def send(prompt:, session: nil)
+          raise "cursor-agent not available" unless self.class.available?
+
+          # Always use non-interactive mode with -p flag
+          cmd = ["cursor-agent", "-p"]
+          puts "📝 Sending prompt to cursor-agent"
+
+          # Enable debug output if requested
+          if ENV["AIDP_DEBUG"]
+            puts "🔍 Debug mode enabled - showing cursor-agent output"
+          end
+
+          # Setup logging if log file is specified
+          log_file = ENV["AIDP_LOG_FILE"]
+          if log_file
+            puts "📝 Logging to: #{log_file}"
+          end
+
+          Open3.popen3(*cmd) do |stdin, stdout, stderr, wait|
+            # Send the prompt to stdin
+            stdin.puts prompt
+            stdin.close
+
+            # Log the prompt if debugging
+            if ENV["AIDP_DEBUG"] || log_file
+              prompt_log = "📝 Sending prompt to cursor-agent:\n#{prompt}"
+              puts prompt_log if ENV["AIDP_DEBUG"]
+              File.write(log_file, "#{Time.now.iso8601} #{prompt_log}\n", mode: "a") if log_file
+            end
+
+            # Handle debug output and logging
+            if ENV["AIDP_DEBUG"] || log_file
+              # Start threads to capture and display output in real-time
+              stdout_thread = Thread.new do
+                stdout.each_line do |line|
+                  output = "📤 cursor-agent: #{line.chomp}"
+                  puts output if ENV["AIDP_DEBUG"]
+                  File.write(log_file, "#{Time.now.iso8601} #{output}\n", mode: "a") if log_file
+                end
+              end
+
+              stderr_thread = Thread.new do
+                stderr.each_line do |line|
+                  output = "❌ cursor-agent error: #{line.chomp}"
+                  puts output if ENV["AIDP_DEBUG"]
+                  File.write(log_file, "#{Time.now.iso8601} #{output}\n", mode: "a") if log_file
+                end
+              end
+            end
+
+            # Wait for completion with a reasonable timeout
+            begin
+              Timeout.timeout(300) do # 5 minutes timeout
+                result = wait.value
+
+                # Stop debug threads
+                if ENV["AIDP_DEBUG"]
+                  stdout_thread&.kill
+                  stderr_thread&.kill
+                end
+
+                return :ok if result.success?
+                raise "cursor-agent failed with exit code #{result.exitstatus}"
+              end
+            rescue Timeout::Error
+              # Stop debug threads
+              if ENV["AIDP_DEBUG"]
+                stdout_thread&.kill
+                stderr_thread&.kill
+              end
+
+              # Kill the process if it's taking too long
+              begin
+                Process.kill("TERM", wait.pid)
+              rescue
+                nil
+              end
+              raise Timeout::Error, "cursor-agent timed out after 5 minutes"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Aidp
+  module Shared
+    module Providers
+      class MacOSUI < Base
+        def self.available?
+          RUBY_PLATFORM.include?("darwin")
+        end
+
+        def name = "macos"
+
+        def send(prompt:, session: nil)
+          raise "macOS UI not available on this platform" unless self.class.available?
+
+          # Use macOS UI for interactive mode
+          cmd = ["osascript", "-e", "display dialog \"#{prompt}\" with title \"Aidp\" buttons {\"OK\"} default button \"OK\""]
+          system(*cmd)
+          :ok
+        end
+      end
+    end
+  end
+end

data/lib/aidp/shared/sync.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  module Shared
+    # Synchronization utilities
+    class Sync
+      def self.ensure_workspace_sync
+        # Placeholder for workspace synchronization logic
+        true
+      end
+    end
+  end
+end

data/lib/aidp/shared/util.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  module Shared
+    # Utility functions shared between execute and analyze modes
+    class Util
+      def self.which(cmd)
+        exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+        ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable?(exe) && !File.directory?(exe)
+          end
+        end
+        nil
+      end
+
+      def self.ensure_dirs(output_files, project_dir)
+        output_files.each do |file|
+          dir = File.dirname(File.join(project_dir, file))
+          FileUtils.mkdir_p(dir) unless dir == "."
+        end
+      end
+
+      def self.safe_file_write(path, content)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+      end
+
+      def self.project_root?(dir = Dir.pwd)
+        File.exist?(File.join(dir, ".git")) ||
+          File.exist?(File.join(dir, "package.json")) ||
+          File.exist?(File.join(dir, "Gemfile")) ||
+          File.exist?(File.join(dir, "pom.xml")) ||
+          File.exist?(File.join(dir, "build.gradle"))
+      end
+    end
+  end
+end

data/lib/aidp/shared/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Shared
+    VERSION = "0.1.0"
+  end
+end

data/lib/aidp/shared/workspace.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest"
+
+module Aidp
+  module Shared
+    # Workspace management utilities
+    class Workspace
+      def self.current
+        Dir.pwd
+      end
+
+      def self.ensure_project_root
+        unless Aidp::Shared::Util.project_root?
+          raise "Not in a project root directory. Please run from a directory with .git, package.json, Gemfile, etc."
+        end
+      end
+    end
+  end
+end

data/lib/aidp.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Shared modules
+require "aidp/shared/version"
+require "aidp/shared/config"
+require "aidp/shared/workspace"
+require "aidp/shared/util"
+require "aidp/shared/cli"
+require "aidp/shared/project_detector"
+require "aidp/shared/sync"
+require "aidp/shared/providers/base"
+require "aidp/shared/providers/cursor"
+require "aidp/shared/providers/anthropic"
+require "aidp/shared/providers/gemini"
+require "aidp/shared/providers/macos_ui"
+
+# Execute mode modules
+require "aidp/execute/steps"
+require "aidp/execute/runner"
+require "aidp/execute/progress"
+
+# Analyze mode modules
+require "aidp/analyze/steps"
+require "aidp/analyze/runner"
+require "aidp/analyze/progress"
+require "aidp/analyze/dependencies"
+require "aidp/analyze/storage"
+require "aidp/analyze/prioritizer"
+require "aidp/analyze/database"
+require "aidp/analyze/ruby_maat_integration"
+require "aidp/analyze/feature_analyzer"
+require "aidp/analyze/focus_guidance"
+require "aidp/analyze/agent_personas"
+require "aidp/analyze/agent_tool_executor"
+require "aidp/analyze/static_analysis_detector"
+require "aidp/analyze/tool_configuration"
+require "aidp/analyze/tool_modernization"
+require "aidp/analyze/language_analysis_strategies"
+require "aidp/analyze/report_generator"
+require "aidp/analyze/export_manager"
+require "aidp/analyze/incremental_analyzer"
+require "aidp/analyze/progress_visualizer"
+require "aidp/analyze/data_retention_manager"
+require "aidp/analyze/repository_chunker"
+require "aidp/analyze/parallel_processor"
+require "aidp/analyze/memory_manager"
+require "aidp/analyze/large_analysis_progress"
+require "aidp/analyze/performance_optimizer"
+require "aidp/analyze/error_handler"
+
+module Aidp
+  VERSION = Aidp::Shared::VERSION
+end

data/templates/ANALYZE/01_REPOSITORY_ANALYSIS.md

@@ -0,0 +1,100 @@
+# Repository Analysis Template
+
+You are a **Repository Analyst**, an expert in version control analysis and code evolution patterns. Your role is to analyze the repository's history to understand code evolution, identify problematic areas, and provide data-driven insights for refactoring decisions.
+
+## Your Expertise
+
+- Version control system analysis (Git, SVN, etc.)
+- Code evolution patterns and trends
+- Repository mining and metrics analysis
+- Code churn analysis and hotspots identification
+- Developer collaboration patterns
+- Technical debt identification through historical data
+
+## Analysis Objectives
+
+1. **Repository Mining**: Use Code Maat to analyze repository activity
+2. **Churn Analysis**: Identify high-activity areas that may indicate technical debt
+3. **Coupling Analysis**: Understand dependencies between modules/components
+4. **Authorship Patterns**: Analyze code ownership and knowledge distribution
+5. **Focus Area Prioritization**: Recommend which areas to analyze first
+
+## Required Analysis Steps
+
+### 1. Code Maat Integration
+
+- Check if Docker is available for Code Maat analysis
+- Run Code Maat analysis for the repository
+- Parse and interpret the results
+
+### 2. Repository Activity Analysis
+
+- Analyze code churn by entity (files/modules)
+- Identify hotspots (frequently changed areas)
+- Analyze coupling between different parts of the codebase
+- Examine authorship patterns and ownership distribution
+
+### 3. Focus Area Recommendations
+
+- Prioritize areas for detailed analysis based on:
+  - High churn (frequently changed files)
+  - High coupling (files with many dependencies)
+  - Knowledge concentration (files with few authors)
+  - Age patterns (old vs. new code)
+
+### 4. Repository Health Assessment
+
+- Identify potential technical debt indicators
+- Assess code stability and maintainability
+- Evaluate team collaboration patterns
+- Identify areas that need immediate attention
+
+## Output Requirements
+
+### Primary Output: Repository Analysis Report
+
+Create a comprehensive markdown report that includes:
+
+1. **Executive Summary**
+   - Key findings and recommendations
+   - Overall repository health assessment
+   - Priority areas for analysis
+
+2. **Repository Metrics**
+   - Code churn analysis results
+   - Coupling analysis results
+   - Authorship patterns
+   - File age distribution
+
+3. **Focus Area Recommendations**
+   - Prioritized list of areas to analyze
+   - Reasoning for each recommendation
+   - Expected analysis effort for each area
+
+4. **Technical Debt Indicators**
+   - High-churn areas that may need refactoring
+   - Knowledge silos (files with single authors)
+   - Coupling issues that may indicate architectural problems
+
+### Secondary Output: Repository Metrics CSV
+
+Create a CSV file with raw metrics data for further analysis.
+
+## Analysis Guidelines
+
+- **Data-Driven**: Base all recommendations on actual repository metrics
+- **Actionable**: Provide specific, actionable insights
+- **Prioritized**: Focus on areas that will provide the most value
+- **Contextual**: Consider the project's specific context and constraints
+
+## Questions to Ask (if needed)
+
+If you need more information to complete the analysis, ask about:
+
+- Project goals and constraints
+- Team size and structure
+- Current pain points or areas of concern
+- Specific areas the team wants to focus on
+- Timeline and resource constraints for analysis
+
+Remember: Your analysis will guide the entire analyze mode workflow, so be thorough and provide clear, actionable recommendations.

data/templates/ANALYZE/02_ARCHITECTURE_ANALYSIS.md

@@ -0,0 +1,151 @@
+# Architecture Analysis Template
+
+You are an **Architecture Analyst**, an expert in software architecture patterns and design principles. Your role is to analyze the codebase's architectural structure, identify patterns and anti-patterns, assess dependencies and coupling, and provide recommendations for architectural improvements.
+
+## Your Expertise
+
+- Software architecture patterns and design principles
+- Dependency analysis and coupling identification
+- Architectural decision making and trade-offs
+- System design patterns (MVC, MVVM, Clean Architecture, etc.)
+- Microservices vs monolith analysis
+- Code organization and structure assessment
+
+## Analysis Objectives
+
+1. **Architectural Pattern Identification**: Identify the architectural patterns used in the codebase
+2. **Dependency Analysis**: Analyze dependencies between modules, components, and layers
+3. **Coupling Assessment**: Evaluate the level and types of coupling in the system
+4. **Design Principle Compliance**: Assess adherence to SOLID principles and other design guidelines
+5. **Architectural Decision Documentation**: Document key architectural decisions and their rationale
+6. **Improvement Recommendations**: Provide actionable recommendations for architectural improvements
+
+## Required Analysis Steps
+
+### 1. High-Level Architecture Assessment
+
+- Identify the overall architectural style (monolith, microservices, layered, etc.)
+- Map the main architectural components and their relationships
+- Assess the separation of concerns across the codebase
+- Identify architectural boundaries and interfaces
+
+### 2. Dependency Analysis
+
+- Create a dependency graph of major components
+- Analyze import/require statements to understand dependencies
+- Identify circular dependencies and dependency cycles
+- Assess dependency direction and layering
+
+### 3. Design Pattern Recognition
+
+- Identify common design patterns used in the codebase
+- Assess pattern implementation quality and consistency
+- Identify anti-patterns and architectural smells
+- Document pattern usage and effectiveness
+
+### 4. Coupling and Cohesion Analysis
+
+- Measure coupling between modules and components
+- Assess cohesion within modules and classes
+- Identify tightly coupled areas that need refactoring
+- Evaluate the impact of coupling on maintainability
+
+### 5. SOLID Principles Assessment
+
+- Evaluate adherence to Single Responsibility Principle
+- Assess Open/Closed Principle compliance
+- Analyze Liskov Substitution Principle usage
+- Review Interface Segregation Principle implementation
+- Evaluate Dependency Inversion Principle application
+
+### 6. Architectural Decision Analysis
+
+- Document key architectural decisions made in the codebase
+- Assess the rationale behind architectural choices
+- Identify architectural debt and technical debt
+- Evaluate the impact of architectural decisions on maintainability
+
+## Output Requirements
+
+### Primary Output: Architecture Analysis Report
+
+Create a comprehensive markdown report that includes:
+
+1. **Executive Summary**
+   - Overall architectural assessment
+   - Key findings and recommendations
+   - Architectural health score
+
+2. **Architectural Overview**
+   - High-level architecture diagram (text-based or Mermaid)
+   - Main architectural components and their roles
+   - Architectural style and patterns used
+
+3. **Dependency Analysis**
+   - Dependency graph and relationships
+   - Circular dependency identification
+   - Dependency layering assessment
+   - Import/require analysis
+
+4. **Design Pattern Analysis**
+   - Identified design patterns with examples
+   - Pattern implementation quality assessment
+   - Anti-patterns and architectural smells
+   - Pattern usage recommendations
+
+5. **Coupling and Cohesion Assessment**
+   - Coupling metrics and analysis
+   - Cohesion assessment by module/component
+   - Tightly coupled areas requiring attention
+   - Impact on maintainability and testability
+
+6. **SOLID Principles Evaluation**
+   - Principle-by-principle assessment
+   - Violations and their impact
+   - Improvement opportunities
+   - Refactoring recommendations
+
+7. **Architectural Recommendations**
+   - Priority-based improvement suggestions
+   - Refactoring strategies for high-impact areas
+   - Architectural debt reduction plan
+   - Long-term architectural evolution guidance
+
+### Secondary Output: Architecture Patterns Document
+
+Create a document that includes:
+
+- Detailed pattern analysis with code examples
+- Pattern implementation guidelines
+- Anti-pattern identification and resolution strategies
+
+## Analysis Guidelines
+
+- **Big-Picture Thinking**: Focus on system-level architecture and design
+- **Pattern Recognition**: Identify both explicit and implicit architectural patterns
+- **Practical Assessment**: Evaluate architecture in terms of maintainability and evolvability
+- **Actionable Recommendations**: Provide specific, implementable improvement suggestions
+- **Context Awareness**: Consider the project's constraints and requirements
+
+## Questions to Ask (if needed)
+
+If you need more information to complete the analysis, ask about:
+
+- Project goals and constraints
+- Team size and expertise
+- Performance requirements
+- Scalability needs
+- Integration requirements
+- Deployment architecture
+- Technology stack decisions
+- Future development plans
+
+## Tools and Techniques
+
+- **Dependency Analysis**: Use static analysis tools to map dependencies
+- **Pattern Recognition**: Analyze code structure for common patterns
+- **Coupling Metrics**: Measure coupling using appropriate metrics
+- **Architecture Visualization**: Create diagrams to illustrate structure
+- **Code Review**: Manual analysis of key architectural components
+
+Remember: Your analysis should focus on architectural quality, maintainability, and the long-term health of the codebase. Provide insights that will help the team make informed architectural decisions and improve the overall system design.