aidp 0.13.0 → 0.14.0

data/lib/aidp/init/project_analyzer.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require "find"
+require "json"
+
+module Aidp
+  module Init
+    # Performs lightweight static analysis of the repository to detect languages,
+    # frameworks, config files, and quality tooling. Designed to run quickly and
+    # deterministically without external services.
+    class ProjectAnalyzer
+      IGNORED_DIRECTORIES = %w[
+        .git
+        .svn
+        .hg
+        node_modules
+        vendor
+        tmp
+        log
+        build
+        dist
+        coverage
+        .yardoc
+      ].freeze
+
+      LANGUAGE_EXTENSIONS = {
+        ".rb" => "Ruby",
+        ".rake" => "Ruby",
+        ".gemspec" => "Ruby",
+        ".js" => "JavaScript",
+        ".jsx" => "JavaScript",
+        ".ts" => "TypeScript",
+        ".tsx" => "TypeScript",
+        ".py" => "Python",
+        ".go" => "Go",
+        ".java" => "Java",
+        ".kt" => "Kotlin",
+        ".cs" => "C#",
+        ".php" => "PHP",
+        ".rs" => "Rust",
+        ".swift" => "Swift",
+        ".scala" => "Scala",
+        ".c" => "C",
+        ".cpp" => "C++",
+        ".hpp" => "C++",
+        ".m" => "Objective-C",
+        ".mm" => "Objective-C++",
+        ".hs" => "Haskell",
+        ".erl" => "Erlang",
+        ".ex" => "Elixir",
+        ".exs" => "Elixir",
+        ".clj" => "Clojure",
+        ".coffee" => "CoffeeScript"
+      }.freeze
+
+      CONFIG_FILES = %w[
+        .editorconfig
+        .rubocop.yml
+        .rubocop_todo.yml
+        .standardrb
+        .eslintrc
+        .eslintrc.js
+        .eslintrc.cjs
+        .eslintrc.json
+        .prettierrc
+        .prettierrc.js
+        .prettierrc.cjs
+        .prettierrc.json
+        .stylelintrc
+        .flake8
+        pyproject.toml
+        tox.ini
+        setup.cfg
+        package.json
+        Gemfile
+        Gemfile.lock
+        mix.exs
+        go.mod
+        go.sum
+        composer.json
+        Cargo.toml
+        Cargo.lock
+        pom.xml
+        build.gradle
+        build.gradle.kts
+      ].freeze
+
+      KEY_DIRECTORIES = %w[
+        app
+        src
+        lib
+        spec
+        test
+        tests
+        scripts
+        bin
+        config
+        docs
+        examples
+        packages
+        modules
+      ].freeze
+
+      TOOLING_HINTS = {
+        rubocop: [".rubocop.yml", ".rubocop_todo.yml"],
+        standardrb: [".standardrb"],
+        eslint: [".eslintrc", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json"],
+        prettier: [".prettierrc", ".prettierrc.js", ".prettierrc.cjs", ".prettierrc.json"],
+        stylelint: [".stylelintrc"],
+        flake8: [".flake8"],
+        black: ["pyproject.toml"],
+        pytest: ["pytest.ini", "pyproject.toml"],
+        jest: ["package.json"],
+        rspec: ["spec", ".rspec"],
+        minitest: ["test"],
+        gofmt: ["go.mod"],
+        cargo_fmt: ["Cargo.toml"]
+      }.freeze
+
+      FRAMEWORK_HINTS = {
+        "Rails" => {files: ["config/application.rb"], contents: [/rails/i]},
+        "Hanami" => {files: ["config/app.rb"], contents: [/hanami/i]},
+        "Sinatra" => {files: ["config.ru"], contents: [/sinatra/i]},
+        "React" => {files: ["package.json"], contents: [/react/]},
+        "Next.js" => {files: ["package.json"], contents: [/next/]},
+        "Express" => {files: ["package.json"], contents: [/express/]},
+        "Angular" => {files: ["angular.json"]},
+        "Vue" => {files: ["package.json"], contents: [/vue/]},
+        "Django" => {files: ["manage.py"], contents: [/django/]},
+        "Flask" => {files: ["requirements.txt"], contents: [/flask/]},
+        "FastAPI" => {files: ["pyproject.toml", "requirements.txt"], contents: [/fastapi/]},
+        "Phoenix" => {files: ["mix.exs"], contents: [/phoenix/]},
+        "Spring" => {files: ["pom.xml", "build.gradle", "build.gradle.kts"], contents: [/spring/]},
+        "Laravel" => {files: ["composer.json"], contents: [/laravel/]},
+        "Go Gin" => {files: ["go.mod"], contents: [/gin-gonic/]},
+        "Go Fiber" => {files: ["go.mod"], contents: [/github.com\/gofiber/]}
+      }.freeze
+
+      TEST_FRAMEWORK_HINTS = {
+        "RSpec" => {directories: ["spec"], dependencies: [/rspec/]},
+        "Minitest" => {directories: ["test"], dependencies: [/minitest/]},
+        "Cucumber" => {directories: ["features"]},
+        "Jest" => {dependencies: [/jest/]},
+        "Mocha" => {dependencies: [/mocha/]},
+        "Jasmine" => {dependencies: [/jasmine/]},
+        "Pytest" => {directories: ["tests", "test"], dependencies: [/pytest/]},
+        "NUnit" => {files: ["*.csproj"], contents: [/nunit/]},
+        "JUnit" => {dependencies: [/junit/]},
+        "Go test" => {files: ["*_test.go"]}
+      }.freeze
+
+      attr_reader :project_dir
+
+      def initialize(project_dir = Dir.pwd)
+        @project_dir = project_dir
+      end
+
+      def analyze
+        {
+          languages: detect_languages,
+          frameworks: detect_frameworks,
+          key_directories: detect_key_directories,
+          config_files: detect_config_files,
+          test_frameworks: detect_test_frameworks,
+          tooling: detect_tooling,
+          repo_stats: collect_repo_stats
+        }
+      end
+
+      private
+
+      def detect_languages
+        counts = Hash.new(0)
+
+        traverse_files do |relative_path|
+          ext = File.extname(relative_path)
+          language = LANGUAGE_EXTENSIONS[ext]
+          next unless language
+
+          full_path = File.join(project_dir, relative_path)
+          counts[language] += File.size(full_path)
+        end
+
+        counts.sort_by { |_lang, weight| -weight }.to_h
+      end
+
+      def detect_frameworks
+        frameworks = Set.new
+
+        FRAMEWORK_HINTS.each do |framework, rules|
+          if rules[:files]&.any? { |file| project_glob?(file) }
+            if rules[:contents]
+              frameworks << framework if rules[:contents].any? { |pattern| search_files_for_pattern(rules[:files], pattern) }
+            else
+              frameworks << framework
+            end
+          elsif rules[:contents]&.any? { |pattern| search_project_for_pattern(pattern) }
+            frameworks << framework
+          end
+        end
+
+        frameworks.to_a.sort
+      end
+
+      def detect_key_directories
+        KEY_DIRECTORIES.select { |dir| Dir.exist?(File.join(project_dir, dir)) }
+      end
+
+      def detect_config_files
+        CONFIG_FILES.select { |file| project_glob?(file) }
+      end
+
+      def detect_test_frameworks
+        results = []
+
+        TEST_FRAMEWORK_HINTS.each do |framework, hints|
+          has_directory = hints[:directories]&.any? { |dir| Dir.exist?(File.join(project_dir, dir)) }
+          has_dependency = hints[:dependencies]&.any? { |pattern| search_project_for_pattern(pattern, limit_files: ["Gemfile", "Gemfile.lock", "package.json", "pyproject.toml", "requirements.txt", "go.mod", "mix.exs", "composer.json", "Cargo.toml"]) }
+          has_files = hints[:files]&.any? { |glob| project_glob?(glob) }
+
+          results << framework if has_directory || has_dependency || has_files
+        end
+
+        results.uniq.sort
+      end
+
+      def detect_tooling
+        tooling = Hash.new { |hash, key| hash[key] = [] }
+
+        TOOLING_HINTS.each do |tool, indicators|
+          hit = indicators.any? do |indicator|
+            if indicator.include?("*")
+            end
+            project_glob?(indicator)
+          end
+          tooling[tool] << "config" if hit
+        end
+
+        # Post-process for package.json to extract scripts referencing linters
+        package_json_path = File.join(project_dir, "package.json")
+        if File.exist?(package_json_path)
+          begin
+            json = JSON.parse(File.read(package_json_path))
+            scripts = json.fetch("scripts", {})
+            tooling[:eslint] << "package.json scripts" if scripts.values.any? { |cmd| cmd.include?("eslint") }
+            tooling[:prettier] << "package.json scripts" if scripts.values.any? { |cmd| cmd.include?("prettier") }
+            tooling[:jest] << "package.json scripts" if scripts.values.any? { |cmd| cmd.include?("jest") }
+          rescue JSON::ParserError
+            # ignore malformed package.json
+          end
+        end
+
+        tooling.delete_if { |_tool, evidence| evidence.empty? }
+      end
+
+      def collect_repo_stats
+        {
+          total_files: counted_files.size,
+          total_directories: counted_directories.size,
+          docs_present: Dir.exist?(File.join(project_dir, "docs")),
+          has_ci_config: project_glob?(".github/workflows/*.yml") || project_glob?(".gitlab-ci.yml"),
+          has_containerization: project_glob?("Dockerfile") || project_glob?("docker-compose.yml")
+        }
+      end
+
+      def counted_files
+        @counted_files ||= begin
+          files = []
+          traverse_files { |path| files << path }
+          files
+        end
+      end
+
+      def counted_directories
+        @counted_directories ||= begin
+          dirs = Set.new
+          traverse_files do |path|
+            dirs << File.dirname(path)
+          end
+          dirs.to_a
+        end
+      end
+
+      def traverse_files
+        Find.find(project_dir) do |path|
+          next if path == project_dir
+
+          relative = path.sub("#{project_dir}/", "")
+          if File.directory?(path)
+            dirname = File.basename(path)
+            if IGNORED_DIRECTORIES.include?(dirname)
+              Find.prune
+            else
+              next
+            end
+          else
+            yield relative
+          end
+        end
+      end
+
+      def project_glob?(pattern)
+        Dir.glob(File.join(project_dir, pattern)).any?
+      end
+
+      def search_files_for_pattern(files, pattern)
+        files.any? do |file|
+          Dir.glob(File.join(project_dir, file)).any? do |path|
+            File.read(path).match?(pattern)
+          rescue Errno::ENOENT, Errno::EISDIR
+            false
+          end
+        end
+      end
+
+      def search_project_for_pattern(pattern, limit_files: nil)
+        if limit_files
+          limit_files.any? do |file|
+            path = File.join(project_dir, file)
+            next false unless File.exist?(path)
+
+            File.read(path).match?(pattern)
+          rescue Errno::ENOENT
+            false
+          end
+        else
+          traverse_files do |relative_path|
+            path = File.join(project_dir, relative_path)
+            begin
+              return true if File.read(path).match?(pattern)
+            rescue Errno::ENOENT
+              next
+            rescue ArgumentError, Encoding::InvalidByteSequenceError => e
+              warn "[AIDP] Skipping file with invalid encoding: #{path} (#{e.class})"
+              next
+            end
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/aidp/init/runner.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../message_display"
+require_relative "project_analyzer"
+require_relative "doc_generator"
+
+module Aidp
+  module Init
+    # High-level coordinator for `aidp init`. Handles analysis, optional user
+    # preferences, and documentation generation.
+    class Runner
+      include Aidp::MessageDisplay
+
+      def initialize(project_dir = Dir.pwd, prompt: TTY::Prompt.new, analyzer: nil, doc_generator: nil)
+        @project_dir = project_dir
+        @prompt = prompt
+        @analyzer = analyzer || ProjectAnalyzer.new(project_dir)
+        @doc_generator = doc_generator || DocGenerator.new(project_dir)
+      end
+
+      def run
+        display_message("🔍 Running aidp init project analysis...", type: :info)
+        analysis = @analyzer.analyze
+        display_summary(analysis)
+
+        preferences = gather_preferences
+
+        @doc_generator.generate(analysis: analysis, preferences: preferences)
+
+        display_message("\n📄 Generated documentation:", type: :info)
+        display_message("  - docs/LLM_STYLE_GUIDE.md", type: :success)
+        display_message("  - docs/PROJECT_ANALYSIS.md", type: :success)
+        display_message("  - docs/CODE_QUALITY_PLAN.md", type: :success)
+        display_message("\n✅ aidp init complete.", type: :success)
+
+        {
+          analysis: analysis,
+          preferences: preferences,
+          generated_files: [
+            "docs/LLM_STYLE_GUIDE.md",
+            "docs/PROJECT_ANALYSIS.md",
+            "docs/CODE_QUALITY_PLAN.md"
+          ]
+        }
+      end
+
+      private
+
+      def display_summary(analysis)
+        languages = analysis[:languages].keys
+        frameworks = analysis[:frameworks]
+        tests = analysis[:test_frameworks]
+        config_files = analysis[:config_files]
+
+        display_message("\n📊 Repository Snapshot", type: :highlight)
+        display_message("  Languages: #{languages.empty? ? "Unknown" : languages.join(", ")}", type: :info)
+        display_message("  Frameworks: #{frameworks.empty? ? "None detected" : frameworks.join(", ")}", type: :info)
+        display_message("  Test suites: #{tests.empty? ? "Not found" : tests.join(", ")}", type: :info)
+        display_message("  Config files: #{config_files.empty? ? "None detected" : config_files.join(", ")}", type: :info)
+      end
+
+      def gather_preferences
+        display_message("\n⚙️  Customise bootstrap plans (press Enter to accept defaults):", type: :info)
+
+        {
+          adopt_new_conventions: ask_yes_no("Adopt the newly generated conventions as canonical defaults?", default: true),
+          stricter_linters: ask_yes_no("Enforce stricter linting based on detected tools?", default: false),
+          migrate_styles: ask_yes_no("Plan migrations to align legacy files with the new style guide?", default: false)
+        }
+      end
+
+      def ask_yes_no(question, default:)
+        @prompt.yes?(question) do |q|
+          q.default default ? "yes" : "no"
+        end
+      rescue NoMethodError
+        # Compatibility with simplified prompts in tests (e.g. TestPrompt)
+        default
+      end
+    end
+  end
+end

data/lib/aidp/init.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "init/project_analyzer"
+require_relative "init/doc_generator"
+require_relative "init/runner"

data/lib/aidp/logger.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require "logger"
+require "json"
+require "fileutils"
+
+module Aidp
+  # Unified structured logger for all AIDP operations
+  # Supports:
+  # - Multiple log levels (info, error, debug)
+  # - Text and JSONL formats
+  # - Automatic rotation
+  # - Redaction of secrets
+  # - Consistent file layout in .aidp/logs/
+  #
+  # Usage:
+  #   Aidp.setup_logger(project_dir, config)
+  #   Aidp.logger.info("component", "message", key: "value")
+  class AidpLogger
+    LEVELS = {
+      debug: ::Logger::DEBUG,
+      info: ::Logger::INFO,
+      warn: ::Logger::WARN,
+      error: ::Logger::ERROR
+    }.freeze
+
+    LOG_DIR = ".aidp/logs"
+    INFO_LOG = "#{LOG_DIR}/aidp.log"
+    DEBUG_LOG = "#{LOG_DIR}/aidp_debug.log"
+
+    DEFAULT_MAX_SIZE = 10 * 1024 * 1024 # 10MB
+    DEFAULT_MAX_FILES = 5
+
+    attr_reader :level, :json_format
+
+    def initialize(project_dir = Dir.pwd, config = {})
+      @project_dir = project_dir
+      @config = config
+      @level = determine_log_level
+      @json_format = config[:json] || false
+      @max_size = config[:max_size_mb] ? config[:max_size_mb] * 1024 * 1024 : DEFAULT_MAX_SIZE
+      @max_files = config[:max_backups] || DEFAULT_MAX_FILES
+
+      ensure_log_directory
+      migrate_old_logs if should_migrate?
+      setup_loggers
+    end
+
+    # Log info level message
+    def info(component, message, **metadata)
+      log(:info, component, message, **metadata)
+    end
+
+    # Log error level message
+    def error(component, message, **metadata)
+      log(:error, component, message, **metadata)
+    end
+
+    # Log warn level message
+    def warn(component, message, **metadata)
+      log(:warn, component, message, **metadata)
+    end
+
+    # Log debug level message
+    def debug(component, message, **metadata)
+      log(:debug, component, message, **metadata)
+    end
+
+    # Log at specified level
+    def log(level, component, message, **metadata)
+      return unless should_log?(level)
+
+      # Redact sensitive data
+      safe_message = redact(message)
+      safe_metadata = redact_hash(metadata)
+
+      # Log to appropriate file(s)
+      if level == :debug
+        write_to_debug(level, component, safe_message, safe_metadata)
+      else
+        write_to_info(level, component, safe_message, safe_metadata)
+      end
+
+      # Always log errors to both files
+      if level == :error
+        write_to_debug(level, component, safe_message, safe_metadata)
+      end
+    end
+
+    # Close all loggers
+    def close
+      @info_logger&.close
+      @debug_logger&.close
+    end
+
+    private
+
+    def determine_log_level
+      # Priority: ENV > config > default
+      level_str = ENV["AIDP_LOG_LEVEL"] || @config[:level] || "info"
+      level_sym = level_str.to_sym
+      LEVELS.key?(level_sym) ? level_sym : :info
+    end
+
+    def should_log?(level)
+      LEVELS[level] >= LEVELS[@level]
+    end
+
+    def ensure_log_directory
+      log_dir = File.join(@project_dir, LOG_DIR)
+      FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
+    end
+
+    def setup_loggers
+      info_path = File.join(@project_dir, INFO_LOG)
+      debug_path = File.join(@project_dir, DEBUG_LOG)
+
+      @info_logger = create_logger(info_path)
+      @debug_logger = create_logger(debug_path)
+    end
+
+    def create_logger(path)
+      logger = ::Logger.new(path, @max_files, @max_size)
+      logger.level = ::Logger::DEBUG # Control at write level instead
+      logger.formatter = proc { |severity, datetime, progname, msg| "#{msg}\n" }
+      logger
+    end
+
+    def write_to_info(level, component, message, metadata)
+      entry = format_entry(level, component, message, metadata)
+      @info_logger.send(logger_method(level), entry)
+    end
+
+    def write_to_debug(level, component, message, metadata)
+      entry = format_entry(level, component, message, metadata)
+      @debug_logger.send(logger_method(level), entry)
+    end
+
+    def logger_method(level)
+      case level
+      when :debug then :debug
+      when :info then :info
+      when :warn then :warn
+      when :error then :error
+      else :info
+      end
+    end
+
+    def format_entry(level, component, message, metadata)
+      if @json_format
+        format_json(level, component, message, metadata)
+      else
+        format_text(level, component, message, metadata)
+      end
+    end
+
+    def format_text(level, component, message, metadata)
+      timestamp = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ")
+      level_str = level.to_s.upcase
+      parts = ["#{timestamp} #{level_str} #{component} #{message}"]
+
+      unless metadata.empty?
+        metadata_str = metadata.map { |k, v| "#{k}=#{redact(v.to_s)}" }.join(" ")
+        parts << "(#{metadata_str})"
+      end
+
+      parts.join(" ")
+    end
+
+    def format_json(level, component, message, metadata)
+      entry = {
+        ts: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ"),
+        level: level.to_s,
+        component: component,
+        msg: message
+      }.merge(metadata)
+
+      JSON.generate(entry)
+    end
+
+    # Redaction patterns for common secrets
+    REDACTION_PATTERNS = [
+      # API keys and tokens (with capture groups)
+      [/\b(api[_-]?key|token|secret|password|passwd|pwd)[=:]\s*['"]?([^\s'")]+)['"]?/i, '\1=<REDACTED>'],
+      # Bearer tokens
+      [/Bearer\s+[A-Za-z0-9\-._~+\/]+=*/, "<REDACTED>"],
+      # GitHub tokens
+      [/\bgh[ps]_[A-Za-z0-9_]{36,}/, "<REDACTED>"],
+      # AWS keys
+      [/\bAKIA[0-9A-Z]{16}/, "<REDACTED>"],
+      # Generic secrets in key=value format
+      [/\b(secret|credentials?|auth)[=:]\s*['"]?([^\s'")]{8,})['"]?/i, '\1=<REDACTED>']
+    ].freeze
+
+    def redact(text)
+      return text unless text.is_a?(String)
+
+      redacted = text.dup
+      REDACTION_PATTERNS.each do |pattern, replacement|
+        redacted.gsub!(pattern, replacement)
+      end
+      redacted
+    end
+
+    def redact_hash(hash)
+      hash.transform_values { |v| v.is_a?(String) ? redact(v) : v }
+    end
+
+    # Migration from old debug_logs location
+    OLD_DEBUG_DIR = ".aidp/debug_logs"
+    OLD_DEBUG_LOG = "#{OLD_DEBUG_DIR}/aidp_debug.log"
+
+    def should_migrate?
+      old_path = File.join(@project_dir, OLD_DEBUG_LOG)
+      new_path = File.join(@project_dir, DEBUG_LOG)
+
+      # Migrate if old exists and new doesn't
+      File.exist?(old_path) && !File.exist?(new_path)
+    end
+
+    def migrate_old_logs
+      old_path = File.join(@project_dir, OLD_DEBUG_LOG)
+      new_path = File.join(@project_dir, DEBUG_LOG)
+
+      begin
+        FileUtils.mv(old_path, new_path)
+        log_migration_notice
+      rescue => e
+        # If migration fails, just continue (new logs will be created)
+        warn "Failed to migrate old logs: #{e.message}"
+      end
+    end
+
+    def log_migration_notice
+      notice = format_text(
+        :info,
+        "migration",
+        "Logs migrated from .aidp/debug_logs/ to .aidp/logs/",
+        timestamp: Time.now.utc.iso8601
+      )
+
+      # Write directly to avoid recursion
+      info_path = File.join(@project_dir, INFO_LOG)
+      File.open(info_path, "a") do |f|
+        f.puts notice
+      end
+    end
+  end
+
+  # Module-level logger accessor
+  class << self
+    # Set up global logger instance
+    def setup_logger(project_dir = Dir.pwd, config = {})
+      @logger = AidpLogger.new(project_dir, config)
+    end
+
+    # Get current logger instance (creates default if not set up)
+    def logger
+      @logger ||= AidpLogger.new
+    end
+
+    # Convenience logging methods
+    def log_info(component, message, **metadata)
+      logger.info(component, message, **metadata)
+    end
+
+    def log_error(component, message, **metadata)
+      logger.error(component, message, **metadata)
+    end
+
+    def log_warn(component, message, **metadata)
+      logger.warn(component, message, **metadata)
+    end
+
+    def log_debug(component, message, **metadata)
+      logger.debug(component, message, **metadata)
+    end
+  end
+end