aidp 0.5.0 → 0.7.0

data/lib/aidp/providers/gemini.rb

@@ -57,8 +57,6 @@ module Aidp
 
               # Stop checking if the process is done
               break if wait.value
-            rescue
-              break
             end
           end
 
@@ -88,8 +86,8 @@ module Aidp
             # Kill the process if it's taking too long
             begin
               Process.kill("TERM", wait.pid)
-            rescue
-              nil
+            rescue Errno::ESRCH
+              # Process already terminated
             end
 
             mark_failed("gemini timed out after #{timeout_seconds} seconds")
@@ -101,8 +99,8 @@ module Aidp
             # Kill the process
             begin
               Process.kill("TERM", wait.pid)
-            rescue
-              nil
+            rescue Errno::ESRCH
+              # Process already terminated
             end
 
             mark_failed("gemini execution was interrupted")

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/aidp.rb

@@ -38,6 +38,12 @@ require "aidp/analyze/runner"
 require "aidp/analyze/steps"
 require "aidp/analyze/progress"
 
+# Tree-sitter analysis
+require "aidp/analysis/tree_sitter_grammar_loader"
+require "aidp/analysis/seams"
+require "aidp/analysis/tree_sitter_scan"
+require "aidp/analysis/kb_inspector"
+
 # Execute mode
 require "aidp/execute/steps"
 require "aidp/execute/runner"

data/templates/ANALYZE/06a_tree_sitter_scan.md

@@ -0,0 +1,217 @@
+# Tree-sitter Static Analysis Template
+
+You are a **Tree-sitter Static Analysis Expert**, specializing in advanced static code analysis using Tree-sitter parsers. Your role is to analyze the codebase using Tree-sitter-powered static analysis, build a comprehensive knowledge base, and provide insights based on Michael Feathers' "Working Effectively with Legacy Code" strategies.
+
+## Your Expertise
+
+- Tree-sitter parser technology and AST analysis
+- Static code analysis and metrics calculation
+- Legacy code refactoring strategies (Feathers' techniques)
+- Seam detection and dependency analysis
+- Code complexity and hotspot identification
+- Test coverage analysis and characterization test recommendations
+
+## Analysis Objectives
+
+1. **Knowledge Base Construction**: Build a comprehensive machine-readable knowledge base of the codebase structure
+2. **Seam Detection**: Identify integration points and dependency injection opportunities using Feathers' strategies
+3. **Hotspot Analysis**: Identify high-change, high-complexity areas that need attention
+4. **Dependency Mapping**: Map import/require relationships and detect cycles
+5. **Test Gap Analysis**: Identify untested public APIs and recommend characterization tests
+6. **Refactoring Opportunities**: Provide specific, actionable refactoring recommendations
+
+## Required Analysis Steps
+
+### 1. Tree-sitter Knowledge Base Generation
+
+Run the Tree-sitter analysis to generate the knowledge base:
+
+```bash
+aidp analyze code --langs ruby,js,ts,py --threads 4
+```
+
+This will generate the following KB files in `.aidp/kb/`:
+
+- `symbols.json` - Classes, modules, methods with metadata
+- `imports.json` - Require/import statements and dependencies
+- `calls.json` - Method call relationships
+- `metrics.json` - Complexity and size metrics
+- `seams.json` - Integration points and dependency injection opportunities
+- `hotspots.json` - High-change, high-complexity areas
+- `tests.json` - Test coverage mapping
+- `cycles.json` - Import/dependency cycles
+
+### 2. Seam Analysis and Feathers' Strategy Application
+
+Analyze the seams data to identify refactoring opportunities:
+
+#### I/O Integration Seams
+
+- **File Operations**: `File.*`, `IO.*`, `Dir.*` calls
+- **Network Operations**: `Net::HTTP.*`, `Socket.*` calls
+- **System Operations**: `Kernel.system`, `Process.*` calls
+- **Database Operations**: `ActiveRecord.*`, `Sequel.*` calls
+
+**Feathers' Recommendations**:
+
+- Extract I/O operations to separate service classes
+- Use dependency injection for external dependencies
+- Create adapter interfaces for external services
+
+#### Global State and Singleton Seams
+
+- **Global Variables**: `$var`, `@@var` usage
+- **Singleton Patterns**: `include Singleton`, `extend Singleton`
+- **Module-level State**: Mutable state in modules
+
+**Feathers' Recommendations**:
+
+- Replace singletons with dependency injection
+- Encapsulate global state in configuration objects
+- Use constructor injection for dependencies
+
+#### Constructor with Work Seams
+
+- **Complex Initialization**: Constructors with significant logic
+- **External Dependencies**: I/O or service calls in constructors
+- **High Complexity**: Constructors with multiple branches
+
+**Feathers' Recommendations**:
+
+- Extract initialization logic to factory methods
+- Use builder pattern for complex object creation
+- Separate construction from initialization
+
+### 3. Hotspot Analysis and Prioritization
+
+Analyze the hotspots data to prioritize refactoring efforts:
+
+#### Hotspot Scoring
+
+- **Change Frequency**: Number of times files have been modified
+- **Complexity**: Cyclomatic complexity and nesting depth
+- **Size**: Lines of code and method count
+- **Dependencies**: Fan-in and fan-out metrics
+
+#### Top 20 Hotspots Analysis
+
+For each hotspot, provide:
+
+- **Rationale**: Why this area is a hotspot
+- **Risk Assessment**: Potential impact of changes
+- **Refactoring Strategy**: Specific Feathers' techniques to apply
+- **Test Strategy**: Characterization test recommendations
+
+### 4. Dependency Cycle Detection
+
+Analyze import cycles and provide breaking strategies:
+
+#### Cycle Types
+
+- **Import Cycles**: Circular require/import dependencies
+- **Call Cycles**: Circular method call dependencies
+- **Inheritance Cycles**: Circular class inheritance
+
+#### Breaking Strategies
+
+- **Dependency Inversion**: Extract interfaces and invert dependencies
+- **Event-Driven Architecture**: Use events to decouple components
+- **Facade Pattern**: Create facades to break direct dependencies
+
+### 5. Test Coverage Analysis
+
+Analyze untested public APIs and recommend characterization tests:
+
+#### Characterization Test Strategy
+
+- **Public API Mapping**: Identify all public methods and classes
+- **Test Coverage**: Map existing tests to public APIs
+- **Gap Analysis**: Identify untested public APIs
+- **Test Recommendations**: Suggest specific characterization tests
+
+#### Test Implementation Guidelines
+
+- **Golden Master Tests**: Capture current behavior before refactoring
+- **Parameterized Tests**: Test with various inputs
+- **Integration Tests**: Test with real dependencies
+- **Mock Tests**: Test with controlled dependencies
+
+## Output Requirements
+
+### 1. Knowledge Base Summary
+
+- Total files analyzed
+- Symbol counts by type (classes, modules, methods)
+- Import/dependency statistics
+- Complexity metrics summary
+
+### 2. Seam Analysis Report
+
+- **I/O Integration Seams**: List with file locations and refactoring suggestions
+- **Global State Seams**: List with specific global usage and encapsulation strategies
+- **Constructor Work Seams**: List with complexity metrics and extraction recommendations
+
+### 3. Hotspot Analysis Report
+
+- **Top 20 Hotspots**: Ranked list with scores and rationale
+- **Refactoring Priorities**: Recommended order for addressing hotspots
+- **Risk Assessment**: Impact analysis for each hotspot
+
+### 4. Dependency Analysis Report
+
+- **Import Graph**: Visualization of file dependencies
+- **Cycle Detection**: List of detected cycles with breaking strategies
+- **Coupling Analysis**: High-coupling areas and decoupling recommendations
+
+### 5. Test Strategy Report
+
+- **Untested APIs**: List of public APIs without tests
+- **Characterization Test Plan**: Specific test recommendations
+- **Test Implementation Guide**: Step-by-step test creation process
+
+### 6. Refactoring Roadmap
+
+- **Phase 1**: Address highest-priority seams and hotspots
+- **Phase 2**: Break dependency cycles
+- **Phase 3**: Implement characterization tests
+- **Phase 4**: Apply systematic refactoring techniques
+
+## Technical Implementation Notes
+
+### Tree-sitter Integration
+
+- Use `aidp analyze code` command to generate KB
+- Leverage `aidp kb show` commands for data inspection
+- Generate graphs with `aidp kb graph` for visualization
+
+### Feathers' Techniques Application
+
+- **Sprout Method**: Extract small methods from large ones
+- **Sprout Class**: Extract new classes for specific responsibilities
+- **Extract Interface**: Create interfaces for dependency injection
+- **Move Method**: Move methods to appropriate classes
+- **Extract Method**: Break down large methods
+
+### Quality Metrics
+
+- **Cyclomatic Complexity**: Target < 10 per method
+- **Lines of Code**: Target < 20 per method
+- **Fan-out**: Target < 7 per method
+- **Nesting Depth**: Target < 4 levels
+
+## Success Criteria
+
+1. **Complete KB Generation**: All source files parsed and analyzed
+2. **Seam Identification**: All integration points identified with specific recommendations
+3. **Hotspot Prioritization**: Top 20 hotspots identified with actionable strategies
+4. **Cycle Detection**: All dependency cycles identified with breaking strategies
+5. **Test Gap Analysis**: All untested public APIs identified with test recommendations
+6. **Refactoring Roadmap**: Prioritized, actionable refactoring plan provided
+
+## Deliverables
+
+1. **Knowledge Base Files**: Complete `.aidp/kb/` directory with all JSON files
+2. **Analysis Report**: Comprehensive markdown report with all findings
+3. **Visualization Files**: Graph files for dependency visualization
+4. **Refactoring Plan**: Detailed, prioritized refactoring roadmap
+5. **Test Strategy**: Specific characterization test recommendations

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Bart Agapinan
 bindir: bin
 cert_chain: []
-date: 2025-08-24 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -219,6 +219,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: ruby_tree_sitter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: The AI-Dev-Pipeline (AIDP) CLI provides a powerful, markdown-driven workflow
   for software development. It supports in-depth project analysis to understand existing
   codebases and an execution mode to systematically implement new features.
@@ -233,6 +247,10 @@ files:
 - README.md
 - bin/aidp
 - lib/aidp.rb
+- lib/aidp/analysis/kb_inspector.rb
+- lib/aidp/analysis/seams.rb
+- lib/aidp/analysis/tree_sitter_grammar_loader.rb
+- lib/aidp/analysis/tree_sitter_scan.rb
 - lib/aidp/analyze/agent_personas.rb
 - lib/aidp/analyze/agent_tool_executor.rb
 - lib/aidp/analyze/data_retention_manager.rb
@@ -269,7 +287,6 @@ files:
 - lib/aidp/database/pg_adapter.rb
 - lib/aidp/database_config.rb
 - lib/aidp/database_connection.rb
-- lib/aidp/database_migration.rb
 - lib/aidp/execute/progress.rb
 - lib/aidp/execute/runner.rb
 - lib/aidp/execute/steps.rb
@@ -296,6 +313,7 @@ files:
 - templates/ANALYZE/04_FUNCTIONALITY_ANALYSIS.md
 - templates/ANALYZE/05_DOCUMENTATION_ANALYSIS.md
 - templates/ANALYZE/06_STATIC_ANALYSIS.md
+- templates/ANALYZE/06a_tree_sitter_scan.md
 - templates/ANALYZE/07_REFACTORING_RECOMMENDATIONS.md
 - templates/COMMON/AGENT_BASE.md
 - templates/COMMON/CONVENTIONS.md
@@ -339,7 +357,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A CLI for AI-driven software development, from analysis to execution.
 test_files: []

data/lib/aidp/database_migration.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require "sqlite3"
-require "fileutils"
-
-module Aidp
-  # Handles database migrations for AIDP
-  class DatabaseMigration
-    def initialize(project_dir = Dir.pwd)
-      @project_dir = project_dir
-      @old_db_path = File.join(project_dir, ".aidp-analysis.db")
-      @new_db_path = File.join(project_dir, ".aidp.db")
-    end
-
-    # Migrate database from old to new format
-    def migrate
-      # If neither database exists, create new one directly
-      if !File.exist?(@old_db_path) && !File.exist?(@new_db_path)
-        create_new_database
-        return true
-      end
-
-      # If new database already exists, skip migration
-      if File.exist?(@new_db_path)
-        puts "Database .aidp.db already exists, skipping migration"
-        return false
-      end
-
-      # Rename old database to new name
-      FileUtils.mv(@old_db_path, @new_db_path)
-
-      # Open database connection
-      db = SQLite3::Database.new(@new_db_path)
-
-      # Create new tables for job management
-      create_job_tables(db)
-
-      # Close connection
-      db.close
-
-      true
-    rescue => e
-      puts "Error during database migration: #{e.message}"
-      # Try to restore old database if something went wrong
-      if File.exist?(@new_db_path) && !File.exist?(@old_db_path)
-        FileUtils.mv(@new_db_path, @old_db_path)
-      end
-      false
-    end
-
-    private
-
-    def create_new_database
-      db = SQLite3::Database.new(@new_db_path)
-
-      # Create original tables
-      create_original_tables(db)
-
-      # Create new job tables
-      create_job_tables(db)
-
-      db.close
-    end
-
-    def create_original_tables(db)
-      # Create analysis_results table
-      db.execute(<<~SQL)
-        CREATE TABLE analysis_results (
-          step_name TEXT PRIMARY KEY,
-          data TEXT NOT NULL,
-          metadata TEXT,
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL
-        )
-      SQL
-
-      # Create analysis_metrics table
-      db.execute(<<~SQL)
-        CREATE TABLE analysis_metrics (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          step_name TEXT NOT NULL,
-          metric_name TEXT NOT NULL,
-          value TEXT NOT NULL,
-          recorded_at TEXT NOT NULL,
-          UNIQUE(step_name, metric_name, recorded_at)
-        )
-      SQL
-
-      # Create embeddings table
-      db.execute(<<~SQL)
-        CREATE TABLE embeddings (
-          step_name TEXT PRIMARY KEY,
-          embeddings_data TEXT NOT NULL,
-          created_at TEXT NOT NULL
-        )
-      SQL
-
-      # Create indexes
-      db.execute("CREATE INDEX idx_analysis_metrics_step_name ON analysis_metrics(step_name)")
-      db.execute("CREATE INDEX idx_analysis_metrics_recorded_at ON analysis_metrics(recorded_at)")
-      db.execute("CREATE INDEX idx_analysis_results_updated_at ON analysis_results(updated_at)")
-    end
-
-    def create_job_tables(db)
-      # Create jobs table
-      db.execute(<<~SQL)
-        CREATE TABLE jobs (
-          id INTEGER PRIMARY KEY,
-          job_type TEXT NOT NULL,
-          provider TEXT NOT NULL,
-          status TEXT NOT NULL,
-          created_at INTEGER NOT NULL,
-          started_at INTEGER,
-          completed_at INTEGER,
-          error TEXT,
-          metadata TEXT
-        )
-      SQL
-
-      # Create job_executions table
-      db.execute(<<~SQL)
-        CREATE TABLE job_executions (
-          id INTEGER PRIMARY KEY,
-          job_id INTEGER NOT NULL,
-          attempt INTEGER NOT NULL,
-          status TEXT NOT NULL,
-          started_at INTEGER NOT NULL,
-          completed_at INTEGER,
-          error TEXT,
-          FOREIGN KEY (job_id) REFERENCES jobs(id)
-        )
-      SQL
-
-      # Create job_logs table
-      db.execute(<<~SQL)
-        CREATE TABLE job_logs (
-          id INTEGER PRIMARY KEY,
-          job_id INTEGER NOT NULL,
-          execution_id INTEGER NOT NULL,
-          timestamp INTEGER NOT NULL,
-          message TEXT NOT NULL,
-          level TEXT NOT NULL,
-          metadata TEXT,
-          FOREIGN KEY (job_id) REFERENCES jobs(id),
-          FOREIGN KEY (execution_id) REFERENCES job_executions(id)
-        )
-      SQL
-
-      # Create indexes for job tables
-      db.execute("CREATE INDEX idx_jobs_status ON jobs(status)")
-      db.execute("CREATE INDEX idx_jobs_provider ON jobs(provider)")
-      db.execute("CREATE INDEX idx_job_executions_job_id ON job_executions(job_id)")
-      db.execute("CREATE INDEX idx_job_logs_job_id ON job_logs(job_id)")
-      db.execute("CREATE INDEX idx_job_logs_execution_id ON job_logs(execution_id)")
-      db.execute("CREATE INDEX idx_job_logs_timestamp ON job_logs(timestamp)")
-    end
-  end
-end