ace-task 0.31.0

data/lib/ace/task/molecules/task_doctor_reporter.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Task
+    module Molecules
+      # Formats doctor diagnosis results for terminal, JSON, or summary output.
+      class TaskDoctorReporter
+        COLORS = {
+          red: "\e[31m",
+          yellow: "\e[33m",
+          green: "\e[32m",
+          blue: "\e[34m",
+          cyan: "\e[36m",
+          reset: "\e[0m",
+          bold: "\e[1m"
+        }.freeze
+
+        ICONS = {
+          error: "❌",
+          warning: "⚠️",
+          info: "ℹ️",
+          success: "✅",
+          doctor: "🏥",
+          stats: "📊",
+          search: "🔍",
+          fix: "🔧",
+          score: "📈"
+        }.freeze
+
+        # Format diagnosis results
+        # @param results [Hash] Results from TaskDoctor#run_diagnosis
+        # @param format [Symbol] Output format (:terminal, :json, :summary)
+        # @param verbose [Boolean] Show verbose output
+        # @param colors [Boolean] Enable colored output
+        # @return [String] Formatted output
+        def self.format_results(results, format: :terminal, verbose: false, colors: true)
+          case format.to_sym
+          when :json
+            format_json(results)
+          when :summary
+            format_summary(results, colors: colors)
+          else
+            format_terminal(results, verbose: verbose, colors: colors)
+          end
+        end
+
+        # Format auto-fix results
+        # @param fix_results [Hash] Results from TaskDoctorFixer#fix_issues
+        # @param colors [Boolean] Enable colored output
+        # @return [String] Formatted fix output
+        def self.format_fix_results(fix_results, colors: true)
+          output = []
+
+          output << if fix_results[:dry_run]
+            "\n#{colorize("#{ICONS[:search]} DRY RUN MODE", :cyan, colors)} - No changes applied"
+          else
+            "\n#{colorize("#{ICONS[:fix]} Auto-Fix Applied", :green, colors)}"
+          end
+
+          if fix_results[:fixed] > 0
+            output << "#{colorize("Fixed:", :green, colors)} #{fix_results[:fixed]} issues"
+
+            if fix_results[:fixes_applied]&.any?
+              output << "\nFixes applied:"
+              fix_results[:fixes_applied].each do |fix|
+                output << "  #{colorize("✓", :green, colors)} #{fix[:description]}"
+                output << "    #{colorize(fix[:file], :blue, colors)}" if fix[:file]
+              end
+            end
+          end
+
+          if fix_results[:skipped] > 0
+            output << "#{colorize("Skipped:", :yellow, colors)} #{fix_results[:skipped]} issues (manual fix required)"
+          end
+
+          output.join("\n")
+        end
+
+        class << self
+          private
+
+          def format_terminal(results, verbose: false, colors: true)
+            output = []
+
+            # Header
+            output << "\n#{colorize("#{ICONS[:doctor]} Task Health Check", :bold, colors)}"
+            output << "=" * 40
+
+            # Stats overview
+            if results[:stats]
+              output << "\n#{colorize("#{ICONS[:stats]} Overview", :cyan, colors)}"
+              output << "-" * 20
+              output << "  Tasks scanned: #{results[:stats][:tasks_scanned]}"
+              output << "  Folders checked: #{results[:stats][:folders_checked]}"
+            end
+
+            # Issues
+            if results[:issues]&.any?
+              output << "\n#{colorize("Issues Found:", :yellow, colors)}"
+              output << "-" * 20
+              output.concat(format_issues(results[:issues], verbose, colors))
+            else
+              output << "\n#{colorize("#{ICONS[:success]} All tasks healthy", :green, colors)}"
+            end
+
+            # Health Score
+            output << "\n#{colorize("#{ICONS[:score]} Health Score:", :bold, colors)} #{format_health_score(results[:health_score], colors)}"
+            output << "=" * 40
+
+            # Summary
+            if results[:stats]
+              output << format_issue_summary(results[:stats], colors)
+            end
+
+            # Duration
+            if results[:duration]
+              output << "\n#{colorize("Completed in #{format_duration(results[:duration])}", :blue, colors)}"
+            end
+
+            output.join("\n")
+          end
+
+          def format_summary(results, colors: true)
+            output = []
+
+            health_status = if results[:health_score] >= 90
+              colorize("Excellent", :green, colors)
+            elsif results[:health_score] >= 70
+              colorize("Good", :yellow, colors)
+            elsif results[:health_score] >= 50
+              colorize("Fair", :yellow, colors)
+            else
+              colorize("Poor", :red, colors)
+            end
+
+            output << "Health: #{health_status} (#{results[:health_score]}/100)"
+
+            if results[:stats]
+              errors = results[:stats][:errors] || 0
+              warnings = results[:stats][:warnings] || 0
+
+              output << colorize("Errors: #{errors}", :red, colors) if errors > 0
+              output << colorize("Warnings: #{warnings}", :yellow, colors) if warnings > 0
+            end
+
+            output.join(" | ")
+          end
+
+          def format_json(results)
+            clean = {
+              health_score: results[:health_score],
+              valid: results[:valid],
+              errors: [],
+              warnings: [],
+              info: [],
+              stats: results[:stats],
+              duration: results[:duration],
+              root_path: results[:root_path]
+            }
+
+            if results[:issues]
+              results[:issues].each do |issue|
+                category = case issue[:type]
+                when :error then :errors
+                when :warning then :warnings
+                else :info
+                end
+                clean[category] << {
+                  message: issue[:message],
+                  location: issue[:location]
+                }
+              end
+            end
+
+            JSON.pretty_generate(clean)
+          end
+
+          def format_issues(issues, verbose, colors)
+            output = []
+            grouped = issues.group_by { |i| i[:type] }
+
+            if grouped[:error]
+              output << "\n#{colorize("#{ICONS[:error]} Errors (#{grouped[:error].size})", :red, colors)}"
+              grouped[:error].each_with_index do |issue, i|
+                output << format_issue(issue, i + 1, colors)
+              end
+            end
+
+            if grouped[:warning]
+              output << "\n#{colorize("#{ICONS[:warning]} Warnings (#{grouped[:warning].size})", :yellow, colors)}"
+              if verbose || grouped[:warning].size <= 10
+                grouped[:warning].each_with_index do |issue, i|
+                  output << format_issue(issue, i + 1, colors)
+                end
+              else
+                grouped[:warning].first(5).each_with_index do |issue, i|
+                  output << format_issue(issue, i + 1, colors)
+                end
+                output << "  ... and #{grouped[:warning].size - 5} more warnings (use --verbose to see all)"
+              end
+            end
+
+            output
+          end
+
+          def format_issue(issue, number, colors)
+            location = issue[:location] ? " (#{colorize(issue[:location], :blue, colors)})" : ""
+            "#{number}. #{issue[:message]}#{location}"
+          end
+
+          def format_health_score(score, colors)
+            color = if score >= 90
+              :green
+            elsif score >= 70
+              :yellow
+            else
+              :red
+            end
+
+            status = if score >= 90
+              "Excellent"
+            elsif score >= 70
+              "Good"
+            elsif score >= 50
+              "Fair"
+            else
+              "Poor"
+            end
+
+            "#{colorize("#{score}/100", color, colors)} (#{status})"
+          end
+
+          def format_issue_summary(stats, colors)
+            parts = []
+            parts << colorize("#{stats[:errors]} errors", :red, colors) if stats[:errors] > 0
+            parts << colorize("#{stats[:warnings]} warnings", :yellow, colors) if stats[:warnings] > 0
+
+            if parts.empty?
+              colorize("No issues found", :green, colors)
+            else
+              parts.join(", ")
+            end
+          end
+
+          def format_duration(duration)
+            if duration < 1
+              "#{(duration * 1000).round}ms"
+            else
+              "#{duration.round(2)}s"
+            end
+          end
+
+          def colorize(text, color, enabled = true)
+            return text unless enabled && COLORS[color]
+
+            "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/molecules/task_frontmatter_validator.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "ace/support/items"
+require_relative "../atoms/task_validation_rules"
+
+module Ace
+  module Task
+    module Molecules
+      # Validates task spec file frontmatter for correctness and completeness.
+      # Returns an array of issue hashes with :type, :message, and :location keys.
+      class TaskFrontmatterValidator
+        # Validate a single task spec file
+        # @param file_path [String] Path to the .s.md file
+        # @param special_folder [String, nil] Special folder the task is in
+        # @return [Array<Hash>] List of issues found
+        def self.validate(file_path, special_folder: nil)
+          issues = []
+
+          unless File.exist?(file_path)
+            issues << {type: :error, message: "File does not exist", location: file_path}
+            return issues
+          end
+
+          content = File.read(file_path)
+
+          # Check delimiters
+          validate_delimiters(content, file_path, issues)
+          return issues if issues.any? { |i| i[:type] == :error }
+
+          # Parse frontmatter
+          frontmatter = parse_frontmatter(content, file_path, issues)
+          return issues unless frontmatter
+
+          # Validate required fields
+          validate_required_fields(frontmatter, file_path, issues)
+
+          # Validate field values
+          validate_field_values(frontmatter, file_path, issues)
+
+          # Validate recommended fields
+          validate_recommended_fields(frontmatter, file_path, issues)
+
+          # Validate scope/status consistency
+          validate_scope_consistency(frontmatter, special_folder, file_path, issues)
+
+          issues
+        end
+
+        class << self
+          private
+
+          def validate_delimiters(content, file_path, issues)
+            lines = content.lines
+
+            unless lines.first&.strip == "---"
+              issues << {type: :error, message: "Missing opening '---' delimiter", location: file_path}
+              return
+            end
+
+            # Find closing delimiter (skip first line)
+            has_closing = lines[1..].any? { |line| line.strip == "---" }
+            unless has_closing
+              issues << {type: :error, message: "Missing closing '---' delimiter", location: file_path}
+            end
+          end
+
+          def parse_frontmatter(content, file_path, issues)
+            frontmatter, _body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
+
+            if frontmatter.nil? || !frontmatter.is_a?(Hash)
+              issues << {type: :error, message: "Failed to parse YAML frontmatter", location: file_path}
+              return nil
+            end
+
+            frontmatter
+          rescue Psych::SyntaxError => e
+            issues << {type: :error, message: "YAML syntax error: #{e.message}", location: file_path}
+            nil
+          end
+
+          def validate_required_fields(frontmatter, file_path, issues)
+            missing = Atoms::TaskValidationRules.missing_required_fields(frontmatter)
+
+            missing.each do |field|
+              severity = (field == "title") ? :warning : :error
+              issues << {type: severity, message: "Missing required field: #{field}", location: file_path}
+            end
+          end
+
+          def validate_field_values(frontmatter, file_path, issues)
+            # Validate ID format
+            if frontmatter["id"] && !Atoms::TaskValidationRules.valid_id?(frontmatter["id"].to_s)
+              issues << {type: :error, message: "Invalid task ID format: '#{frontmatter["id"]}'", location: file_path}
+            end
+
+            # Validate status value
+            if frontmatter["status"] && !Atoms::TaskValidationRules.valid_status?(frontmatter["status"])
+              issues << {type: :error, message: "Invalid status value: '#{frontmatter["status"]}'", location: file_path}
+            end
+
+            # Validate tags is an array
+            if frontmatter.key?("tags") && !frontmatter["tags"].is_a?(Array)
+              issues << {type: :warning, message: "Field 'tags' is not an array", location: file_path}
+            end
+
+            # Validate title length
+            title = frontmatter["title"].to_s
+            if title.length > Atoms::TaskValidationRules::MAX_TITLE_LENGTH
+              issues << {type: :warning, message: "Title exceeds #{Atoms::TaskValidationRules::MAX_TITLE_LENGTH} characters (#{title.length} chars)", location: file_path}
+            end
+          end
+
+          def validate_recommended_fields(frontmatter, file_path, issues)
+            missing = Atoms::TaskValidationRules.missing_recommended_fields(frontmatter)
+
+            missing.each do |field|
+              issues << {type: :warning, message: "Missing recommended field: #{field}", location: file_path}
+            end
+          end
+
+          def validate_scope_consistency(frontmatter, special_folder, file_path, issues)
+            return unless frontmatter["status"]
+
+            scope_issues = Atoms::TaskValidationRules.scope_consistent?(
+              frontmatter["status"],
+              special_folder
+            )
+
+            scope_issues.each do |issue|
+              issues << issue.merge(location: file_path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/molecules/task_loader.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "ace/support/items"
+require "ace/b36ts"
+require_relative "../atoms/task_file_pattern"
+require_relative "../models/task"
+
+module Ace
+  module Task
+    module Molecules
+      # Loads a single task from its directory.
+      # Parses the spec file frontmatter and content into a Task model.
+      # Detects subtasks from folder co-location.
+      class TaskLoader
+        # Load a task from a directory
+        # @param dir_path [String] Path to the task directory
+        # @param id [String] Formatted task ID (e.g., "8pp.t.q7w")
+        # @param special_folder [String, nil] Special folder name if applicable
+        # @param load_subtasks [Boolean] Whether to scan for subtask directories (default: true)
+        # @return [Models::Task] Loaded task
+        def load(dir_path, id:, special_folder: nil, load_subtasks: true)
+          spec_files = Dir.glob(File.join(dir_path, "*.s.md"))
+          return nil if spec_files.empty?
+
+          # Find primary spec file matching the folder ID
+          spec_file = find_primary_spec(spec_files, id) || spec_files.first
+          content = File.read(spec_file)
+
+          # Parse frontmatter
+          frontmatter, body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
+
+          # Extract title from body
+          title = Ace::Support::Items::Atoms::TitleExtractor.extract(body) ||
+            frontmatter["title"] ||
+            File.basename(dir_path)
+
+          # Decode creation time from raw b36ts
+          created_at = decode_created_at(id)
+
+          # Detect parent_id from frontmatter
+          parent_id = frontmatter["parent"]
+
+          # Load subtasks from co-located directories
+          subtasks = if load_subtasks && !parent_id
+            load_subtask_dirs(dir_path, id, special_folder)
+          else
+            []
+          end
+
+          Models::Task.new(
+            id: id,
+            status: frontmatter["status"] || "pending",
+            title: title,
+            priority: frontmatter["priority"] || "medium",
+            estimate: frontmatter["estimate"],
+            dependencies: Array(frontmatter["dependencies"]),
+            tags: Array(frontmatter["tags"]),
+            content: body,
+            path: dir_path,
+            file_path: spec_file,
+            special_folder: special_folder,
+            created_at: created_at,
+            subtasks: subtasks,
+            parent_id: parent_id,
+            metadata: frontmatter
+          )
+        end
+
+        private
+
+        # Find the primary spec file matching the task ID (not a subtask file).
+        def find_primary_spec(spec_files, folder_id)
+          spec_files.find do |f|
+            Atoms::TaskFilePattern.primary_file?(File.basename(f), folder_id)
+          end
+        end
+
+        def decode_created_at(id)
+          raw_b36ts = Ace::Support::Items::Atoms::ItemIdFormatter.reconstruct(id)
+          Ace::B36ts.decode(raw_b36ts)
+        rescue
+          nil
+        end
+
+        # Scan for subtask directories within the parent task directory.
+        def load_subtask_dirs(parent_dir, parent_id, special_folder)
+          subtask_dirs = find_subtask_dirs(parent_dir, parent_id)
+          subtask_dirs.filter_map do |subtask_id, subtask_dir|
+            load(subtask_dir, id: subtask_id, special_folder: special_folder, load_subtasks: false)
+          end
+        end
+
+        # Find all subtask directories within a parent directory.
+        # Returns array of [subtask_id, dir_path] pairs.
+        # Supports short format ("0-slug").
+        def find_subtask_dirs(parent_dir, parent_id)
+          results = []
+          return results unless Dir.exist?(parent_dir)
+
+          Dir.entries(parent_dir).sort.each do |entry|
+            next if entry.start_with?(".")
+
+            full_path = File.join(parent_dir, entry)
+            next unless File.directory?(full_path)
+
+            # New short format: "0-slug" or "a-slug"
+            if (short_match = entry.match(/^([a-z0-9])-/))
+              subtask_id = "#{parent_id}.#{short_match[1]}"
+              results << [subtask_id, full_path]
+              next
+            end
+          end
+
+          results
+        end
+      end
+    end
+  end
+end