ace-task 0.31.0

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

@@ -0,0 +1,510 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+require "ace/support/markdown"
+require "ace/support/items"
+require_relative "../atoms/task_id_formatter"
+require_relative "../atoms/task_validation_rules"
+require_relative "../atoms/task_frontmatter_defaults"
+require_relative "task_scanner"
+
+module Ace
+  module Task
+    module Molecules
+      # Handles auto-fixing of common task issues detected by doctor.
+      # Supports dry_run mode to preview fixes without applying them.
+      class TaskDoctorFixer
+        attr_reader :dry_run, :fixed_count, :skipped_count
+
+        def initialize(dry_run: false, root_dir: nil)
+          @dry_run = dry_run
+          @root_dir = root_dir
+          @fixed_count = 0
+          @skipped_count = 0
+          @fixes_applied = []
+        end
+
+        # Fix a batch of issues
+        # @param issues [Array<Hash>] Issues to fix
+        # @return [Hash] Fix results summary
+        def fix_issues(issues)
+          fixable_issues = issues.select { |issue| can_fix?(issue) }
+
+          fixable_issues.each do |issue|
+            fix_issue(issue)
+          end
+
+          {
+            fixed: @fixed_count,
+            skipped: @skipped_count,
+            fixes_applied: @fixes_applied,
+            dry_run: @dry_run
+          }
+        end
+
+        # Fix a single issue by pattern matching its message
+        # @param issue [Hash] Issue to fix
+        # @return [Boolean] Whether fix was successful
+        def fix_issue(issue)
+          case issue[:message]
+          when /Missing opening '---' delimiter/
+            fix_missing_opening_delimiter(issue[:location])
+          when /Missing closing '---' delimiter/
+            fix_missing_closing_delimiter(issue[:location])
+          when /Missing required field: id/
+            fix_missing_id(issue[:location])
+          when /Missing required field: status/,
+               /Missing recommended field: status/
+            fix_missing_status(issue[:location])
+          when /Missing required field: title/,
+               /Missing recommended field: title/
+            fix_missing_title(issue[:location])
+          when /Field 'tags' is not an array/
+            fix_tags_not_array(issue[:location])
+          when /Missing recommended field: tags/
+            fix_missing_tags(issue[:location])
+          when /Missing recommended field: created_at/
+            fix_missing_created_at(issue[:location])
+          when /terminal status.*not in _archive/
+            fix_move_to_archive(issue[:location])
+          when /in _archive\/ but status is/
+            fix_archive_status(issue[:location])
+          when /in _maybe\/ with terminal status/
+            fix_maybe_terminal(issue[:location])
+          when /Stale backup file/
+            fix_stale_backup(issue[:location])
+          when /Empty directory/
+            fix_empty_directory(issue[:location])
+          when /Folder name does not match '\{id\}-\{slug\}' convention/
+            fix_folder_naming(issue[:location])
+          else
+            @skipped_count += 1
+            false
+          end
+        end
+
+        # Check if an issue can be auto-fixed
+        # @param issue [Hash] Issue to check
+        # @return [Boolean]
+        def can_fix?(issue)
+          return false unless issue[:location]
+
+          FIXABLE_PATTERNS.any? { |pattern| issue[:message].match?(pattern) }
+        end
+
+        private
+
+        FIXABLE_PATTERNS = [
+          /Missing opening '---' delimiter/,
+          /Missing closing '---' delimiter/,
+          /Missing required field: id/,
+          /Missing required field: status/,
+          /Missing required field: title/,
+          /Missing recommended field: status/,
+          /Missing recommended field: title/,
+          /Missing recommended field: tags/,
+          /Missing recommended field: created_at/,
+          /Field 'tags' is not an array/,
+          /terminal status.*not in _archive/,
+          /in _archive\/ but status is/,
+          /in _maybe\/ with terminal status/,
+          /Stale backup file/,
+          /Empty directory/,
+          /Folder name does not match '\{id\}-\{slug\}' convention/
+        ].freeze
+
+        def fix_missing_closing_delimiter(file_path)
+          return false unless File.exist?(file_path)
+
+          content = File.read(file_path)
+          lines = content.lines
+          insert_idx = nil
+          lines[1..].each_with_index do |line, i|
+            if line.strip.empty? || line.start_with?("#")
+              insert_idx = i + 1
+              break
+            end
+          end
+          insert_idx ||= lines.size
+
+          fixed_lines = lines.dup
+          fixed_lines.insert(insert_idx, "---\n")
+          fixed_content = fixed_lines.join
+
+          apply_file_fix(file_path, fixed_content, "Added missing closing '---' delimiter")
+        end
+
+        def fix_missing_id(file_path)
+          return false unless File.exist?(file_path)
+
+          # Extract ID from folder name using task pattern (xxx.t.yyy)
+          dir_name = File.basename(File.dirname(file_path))
+          id_and_slug = TaskScanner::TASK_ID_EXTRACTOR.call(dir_name)
+          unless id_and_slug
+            return (@skipped_count += 1
+                    false)
+          end
+
+          id = id_and_slug[0]
+          update_frontmatter_field(file_path, "id", id, "Added missing 'id' field from folder name")
+        end
+
+        def fix_missing_status(file_path)
+          update_frontmatter_field(file_path, "status", "pending", "Added missing 'status' field with default 'pending'")
+        end
+
+        def fix_missing_title(file_path)
+          return false unless File.exist?(file_path)
+
+          content = File.read(file_path)
+          # Try to extract title from body H1
+          title = nil
+          _fm, body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
+          if body
+            h1_match = body.match(/^#\s+(.+)/)
+            title = h1_match[1].strip if h1_match
+          end
+
+          # Fallback: extract from folder slug
+          unless title
+            dir_name = File.basename(File.dirname(file_path))
+            id_and_slug = TaskScanner::TASK_ID_EXTRACTOR.call(dir_name)
+            title = if id_and_slug
+              id_and_slug[1].tr("-", " ").capitalize
+            else
+              "Untitled"
+            end
+          end
+
+          update_frontmatter_field(file_path, "title", title, "Added missing 'title' field: '#{title}'")
+        end
+
+        def fix_tags_not_array(file_path)
+          update_frontmatter_field(file_path, "tags", [], "Coerced 'tags' field to empty array")
+        end
+
+        def fix_missing_tags(file_path)
+          update_frontmatter_field(file_path, "tags", [], "Added missing 'tags' field with empty array")
+        end
+
+        def fix_missing_created_at(file_path)
+          return false unless File.exist?(file_path)
+
+          content = File.read(file_path)
+          frontmatter, _body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
+
+          id = frontmatter&.dig("id")
+          unless id
+            dir_name = File.basename(File.dirname(file_path))
+            id_and_slug = TaskScanner::TASK_ID_EXTRACTOR.call(dir_name)
+            id = id_and_slug[0] if id_and_slug
+          end
+
+          created_at = if id && Atoms::TaskValidationRules.valid_id?(id)
+            raw = Atoms::TaskIdFormatter.reconstruct(id)
+            Ace::B36ts.decode(raw).strftime("%Y-%m-%d %H:%M:%S")
+          else
+            Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+          end
+
+          update_frontmatter_field(file_path, "created_at", created_at, "Added missing 'created_at' field decoded from ID")
+        end
+
+        def fix_move_to_archive(file_path)
+          return false unless file_path && @root_dir
+
+          move_issue_to_archive(file_path, from_maybe: false)
+        end
+
+        def fix_archive_status(file_path)
+          update_frontmatter_field(file_path, "status", "done", "Updated status to 'done' (in _archive/)")
+        end
+
+        def fix_maybe_terminal(file_path)
+          return false unless file_path && @root_dir
+
+          move_issue_to_archive(file_path, from_maybe: true)
+        end
+
+        BACKUP_EXTENSIONS = /\.(backup\.\w+|tmp)$|~$/
+
+        def fix_stale_backup(file_path)
+          return false unless file_path && File.exist?(file_path)
+          unless File.basename(file_path).match?(BACKUP_EXTENSIONS)
+            @skipped_count += 1
+            return false
+          end
+
+          if @dry_run
+            log_fix(file_path, "Would delete stale backup file")
+          else
+            File.delete(file_path)
+            log_fix(file_path, "Deleted stale backup file")
+          end
+
+          @fixed_count += 1
+          true
+        end
+
+        def fix_empty_directory(dir_path)
+          return false unless dir_path && Dir.exist?(dir_path)
+
+          # Safety: only remove if truly empty
+          files = Dir.glob(File.join(dir_path, "**", "*")).select { |f| File.file?(f) }
+          unless files.empty?
+            @skipped_count += 1
+            return false
+          end
+
+          if @dry_run
+            log_fix(dir_path, "Would delete empty directory")
+          else
+            FileUtils.rm_rf(dir_path)
+            log_fix(dir_path, "Deleted empty directory")
+          end
+
+          @fixed_count += 1
+          true
+        end
+
+        def fix_missing_opening_delimiter(file_path)
+          return false unless File.exist?(file_path)
+
+          content = File.read(file_path)
+
+          # Extract ID from folder name
+          dir_name = File.basename(File.dirname(file_path))
+          id_and_slug = TaskScanner::TASK_ID_EXTRACTOR.call(dir_name)
+          id = id_and_slug ? id_and_slug[0] : nil
+
+          # Extract title from first H1 or folder slug
+          title = extract_title_from_content(content) || extract_slug_title(dir_name)
+
+          # Build minimal frontmatter
+          frontmatter = Atoms::TaskFrontmatterDefaults.build(
+            id: id || Atoms::TaskIdFormatter.generate.formatted_id,
+            status: "pending",
+            created_at: Time.now.utc
+          )
+          frontmatter["title"] = title
+          frontmatter["id"] = id if id # Use existing ID if available
+
+          # Prepend proper frontmatter structure
+          yaml_block = "---\n#{YAML.dump(frontmatter).sub(/^---\n/, "")}---\n"
+          new_content = "#{yaml_block}\n#{content}"
+
+          apply_file_fix(file_path, new_content, "Added opening '---' delimiter and frontmatter")
+        end
+
+        def fix_folder_naming(dir_path)
+          return false unless Dir.exist?(dir_path)
+
+          # Generate new valid ID
+          item_id = Atoms::TaskIdFormatter.generate
+          new_id = item_id.formatted_id
+
+          # Extract slug from old folder name
+          old_name = File.basename(dir_path)
+          slug = extract_slug_from_folder_name(old_name)
+
+          # Find spec file
+          spec_files = Dir.glob(File.join(dir_path, "*.s.md"))
+            .reject { |f| f.end_with?(".idea.s.md") }
+          if spec_files.empty?
+            return (@skipped_count += 1
+                    false)
+          end
+
+          spec_file = spec_files.first
+
+          if @dry_run
+            new_folder_name = "#{new_id}-#{slug}"
+            log_fix(dir_path, "Would rename folder to #{new_folder_name}")
+            @fixed_count += 1
+            return true
+          end
+
+          # Update frontmatter id in spec file
+          editor = Ace::Support::Markdown::Organisms::DocumentEditor.new(spec_file)
+          editor.update_frontmatter("id" => new_id)
+          editor.save!(backup: true, validate_before: false)
+
+          # Build new names
+          new_folder_name = "#{new_id}-#{slug}"
+          parent = File.dirname(dir_path)
+          new_dir_path = File.join(parent, new_folder_name)
+
+          # Rename spec file
+          old_spec_name = File.basename(spec_file)
+          new_spec_name = "#{new_folder_name}.s.md"
+
+          # Rename folder
+          FileUtils.mv(dir_path, new_dir_path)
+          FileUtils.mv(File.join(new_dir_path, old_spec_name), File.join(new_dir_path, new_spec_name))
+
+          log_fix(dir_path, "Renamed folder to #{new_folder_name}")
+          @fixed_count += 1
+          true
+        rescue => e
+          log_fix(e.message, "Error: #{e.class}")
+          @skipped_count += 1
+          false
+        end
+
+        def extract_title_from_content(content)
+          h1_match = content.match(/^#\s+(.+)$/)
+          h1_match ? h1_match[1].strip : nil
+        end
+
+        def extract_slug_title(dir_name)
+          id_and_slug = TaskScanner::TASK_ID_EXTRACTOR.call(dir_name)
+          slug = id_and_slug ? id_and_slug[1] : dir_name
+          slug.tr("-", " ").capitalize
+        end
+
+        def extract_slug_from_folder_name(name)
+          # Remove task ID prefix patterns
+          slug = name.sub(/^[0-9a-z]{3}\.[a-z]\.[0-9a-z]{3}-/, "") # Remove xxx.t.yyy-
+            .sub(/^\d+-\d+-\d+-/, "")                        # Remove NNN-YYYYMMDD-HHMMSS-
+            .sub(/^\d{7,}-/, "")                              # Remove 7+ digit prefix
+            .sub(/^\d{6}-/, "")                               # Remove 6-digit date prefix
+            .sub(/^\d+-/, "")                                 # Remove issue number prefix
+
+          if slug.empty? || slug.match?(/^\d+$/)
+            slug = name.gsub(/[^a-zA-Z0-9]+/, "-").downcase
+          end
+
+          slug = slug.gsub(/^-+|-+$/, "")
+          slug = "untitled" if slug.empty?
+          slug[0..50]
+        end
+
+        def update_frontmatter_field(file_path, field, value, description)
+          return false unless file_path && File.exist?(file_path)
+
+          if @dry_run
+            log_fix(file_path, "Would: #{description}")
+            @fixed_count += 1
+            return true
+          end
+
+          editor = Ace::Support::Markdown::Organisms::DocumentEditor.new(file_path)
+          editor.update_frontmatter(field => value)
+          editor.save!(backup: true, validate_before: false)
+          log_fix(file_path, description)
+          @fixed_count += 1
+          true
+        rescue => e
+          log_fix(e.message, "Error: #{e.class}")
+          @skipped_count += 1
+          false
+        end
+
+        def apply_file_fix(file_path, new_content, description)
+          if @dry_run
+            log_fix(file_path, "Would: #{description}")
+          else
+            Ace::Support::Markdown::Organisms::SafeFileWriter.write(
+              file_path,
+              new_content,
+              backup: true
+            )
+            log_fix(file_path, description)
+          end
+
+          @fixed_count += 1
+          true
+        rescue => e
+          log_fix(e.message, "Error: #{e.class}")
+          @skipped_count += 1
+          false
+        end
+
+        def log_fix(file_path, description)
+          @fixes_applied << {
+            file: file_path,
+            description: description,
+            timestamp: Time.now
+          }
+        end
+
+        def move_issue_to_archive(file_path, from_maybe:)
+          task_file = File.directory?(file_path) ? find_primary_spec(file_path) : file_path
+          unless task_file && File.exist?(task_file)
+            return (@skipped_count += 1
+                    false)
+          end
+
+          task_dir = File.dirname(task_file)
+          content = File.read(task_file)
+          frontmatter, _body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
+          parent_id = frontmatter.is_a?(Hash) ? frontmatter["parent"] : nil
+          archive_time = parse_archive_time(frontmatter)
+
+          source_dir = task_dir
+          description = from_maybe ? "Moved from _maybe/ to _archive/" : "Moved to _archive/"
+
+          if parent_id
+            parent_dir = File.dirname(task_dir)
+            unless all_siblings_terminal?(parent_dir, parent_id)
+              log_fix(task_dir, "Skipped archive move for subtask (siblings are not all terminal)")
+              @skipped_count += 1
+              return false
+            end
+            source_dir = parent_dir
+            description = "Moved parent task to _archive/ (all subtasks terminal)"
+          end
+
+          if @dry_run
+            log_fix(source_dir, "Would #{description.downcase}")
+            @fixed_count += 1
+            return true
+          end
+
+          mover = Ace::Support::Items::Molecules::FolderMover.new(@root_dir)
+          mover.move(Struct.new(:path).new(source_dir), to: "archive", date: archive_time)
+          log_fix(source_dir, description)
+          @fixed_count += 1
+          true
+        rescue => e
+          log_fix(e.message, "Error: #{e.class}")
+          @skipped_count += 1
+          false
+        end
+
+        def find_primary_spec(dir_path)
+          Dir.glob(File.join(dir_path, "*.s.md"))
+            .reject { |path| path.end_with?(".idea.s.md") }
+            .first
+        end
+
+        def parse_archive_time(frontmatter)
+          return nil unless frontmatter.is_a?(Hash)
+
+          raw = frontmatter["completed_at"] || frontmatter["created_at"]
+          return nil unless raw
+          return raw if raw.is_a?(Time)
+          return raw.to_time if raw.respond_to?(:to_time)
+
+          Time.parse(raw.to_s)
+        rescue ArgumentError
+          nil
+        end
+
+        def all_siblings_terminal?(parent_dir, parent_id)
+          scanner = TaskScanner.new(@root_dir)
+          subtasks = scanner.scan_subtasks(parent_dir, parent_id: parent_id)
+          return false if subtasks.empty?
+
+          subtasks.all? do |scan_result|
+            content = File.read(scan_result.file_path)
+            frontmatter, _body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
+            status = frontmatter.is_a?(Hash) ? frontmatter["status"] : nil
+            Atoms::TaskValidationRules.terminal_status?(status.to_s.downcase)
+          end
+        end
+      end
+    end
+  end
+end