enhance_swarm 1.0.0

data/lib/enhance_swarm/task_integration.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative 'logger'
+
+module EnhanceSwarm
+  class TaskIntegration
+    def initialize
+      @tasks_available = check_swarm_tasks_availability
+    end
+
+    def swarm_tasks_available?
+      @tasks_available
+    end
+
+    def list_tasks
+      return [] unless @tasks_available
+
+      begin
+        output = `bundle exec swarm-tasks list --format=json 2>/dev/null`
+        return [] if output.empty?
+
+        JSON.parse(output)
+      rescue JSON::ParserError, StandardError => e
+        Logger.warn("Failed to parse swarm-tasks output: #{e.message}")
+        []
+      end
+    end
+
+    def get_active_tasks
+      tasks = list_tasks
+      tasks.select { |task| task['status'] == 'active' || task['status'] == 'in_progress' }
+    end
+
+    def move_task(task_id, status)
+      return false unless @tasks_available
+
+      begin
+        result = `bundle exec swarm-tasks move #{task_id} #{status} 2>/dev/null`
+        $?.success?
+      rescue StandardError => e
+        Logger.error("Failed to move task #{task_id} to #{status}: #{e.message}")
+        false
+      end
+    end
+
+    def create_task(title, description = nil, priority = 'medium')
+      return false unless @tasks_available
+
+      begin
+        cmd = "bundle exec swarm-tasks create \"#{title}\""
+        cmd += " --description=\"#{description}\"" if description
+        cmd += " --priority=#{priority}"
+        cmd += " 2>/dev/null"
+        
+        result = `#{cmd}`
+        $?.success?
+      rescue StandardError => e
+        Logger.error("Failed to create task: #{e.message}")
+        false
+      end
+    end
+
+    def get_task_folders
+      return [] unless @tasks_available
+
+      begin
+        # Look for tasks directory structure
+        tasks_dir = File.join(Dir.pwd, 'tasks')
+        return [] unless Dir.exist?(tasks_dir)
+
+        folders = []
+        Dir.glob(File.join(tasks_dir, '*')).each do |path|
+          next unless File.directory?(path)
+          
+          folder_name = File.basename(path)
+          task_files = Dir.glob(File.join(path, '*.md')).length
+          
+          folders << {
+            name: folder_name,
+            path: path,
+            task_count: task_files,
+            status: folder_name # todo, in_progress, done, etc.
+          }
+        end
+
+        folders
+      rescue StandardError => e
+        Logger.warn("Failed to analyze task folders: #{e.message}")
+        []
+      end
+    end
+
+    def get_kanban_data
+      {
+        swarm_tasks_available: @tasks_available,
+        tasks: list_tasks,
+        folders: get_task_folders,
+        active_tasks: get_active_tasks
+      }
+    end
+
+    def setup_task_management
+      return false unless @tasks_available
+
+      begin
+        # Initialize swarm-tasks if not already done
+        unless Dir.exist?(File.join(Dir.pwd, 'tasks'))
+          Logger.info("Initializing swarm-tasks for project")
+          `bundle exec swarm-tasks init 2>/dev/null`
+        end
+
+        # Create default task categories if they don't exist
+        default_folders = ['todo', 'in_progress', 'review', 'done']
+        tasks_dir = File.join(Dir.pwd, 'tasks')
+        
+        default_folders.each do |folder|
+          folder_path = File.join(tasks_dir, folder)
+          unless Dir.exist?(folder_path)
+            FileUtils.mkdir_p(folder_path)
+            Logger.info("Created task folder: #{folder}")
+          end
+        end
+
+        true
+      rescue StandardError => e
+        Logger.error("Failed to setup task management: #{e.message}")
+        false
+      end
+    end
+
+    private
+
+    def check_swarm_tasks_availability
+      begin
+        # Check if swarm-tasks gem is available
+        require 'swarm_tasks'
+        
+        # Check if swarm-tasks command is available
+        result = `bundle exec swarm-tasks --version 2>/dev/null`
+        $?.success?
+      rescue LoadError
+        Logger.warn("swarm-tasks gem not available - task management features limited")
+        false
+      rescue StandardError => e
+        Logger.warn("swarm-tasks not accessible: #{e.message}")
+        false
+      end
+    end
+  end
+end

data/lib/enhance_swarm/task_manager.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'command_executor'
+
+module EnhanceSwarm
+  class TaskManager
+    def initialize
+      @config = EnhanceSwarm.configuration
+    end
+
+    def next_priority_task
+      # Try to use swarm-tasks if available
+      if swarm_tasks_available?
+        list_swarm_tasks('backlog').first
+      else
+        # Fallback to simple file-based tasks
+        find_next_file_task
+      end
+    end
+
+    def find_task(task_id)
+      if swarm_tasks_available?
+        show_swarm_task(task_id)
+      else
+        find_file_task(task_id)
+      end
+    end
+
+    def move_task(task_id, state)
+      if swarm_tasks_available?
+        begin
+          CommandExecutor.execute(@config.task_command, 'move', task_id.to_s, state.to_s)
+        rescue CommandExecutor::CommandError => e
+          puts "Failed to move task: #{e.message}".colorize(:red)
+          false
+        end
+      else
+        puts 'Task management not configured. Please set up swarm-tasks.'.colorize(:yellow)
+        false
+      end
+    end
+
+    def list_tasks(state = 'all')
+      if swarm_tasks_available?
+        list_swarm_tasks(state)
+      else
+        list_file_tasks(state)
+      end
+    end
+
+    private
+
+    def swarm_tasks_available?
+      CommandExecutor.command_available?(@config.task_command.split.first)
+    rescue CommandExecutor::CommandError
+      false
+    end
+
+    def list_swarm_tasks(state)
+      output = CommandExecutor.execute(@config.task_command, 'list', state, '--json')
+      return [] if output.empty?
+
+      tasks = JSON.parse(output)
+      tasks.map do |task|
+        {
+          id: task['id'],
+          title: task['title'] || task['content'],
+          description: task['description'] || task['content'],
+          state: task['state'] || task['status'],
+          priority: task['priority'],
+          effort: task['effort'],
+          tags: task['tags'] || []
+        }
+      end
+    rescue CommandExecutor::CommandError, JSON::ParserError
+      []
+    end
+
+    def show_swarm_task(task_id)
+      output = CommandExecutor.execute(@config.task_command, 'show', task_id.to_s, '--json')
+      return nil if output.empty?
+
+      task = JSON.parse(output)
+      {
+        id: task['id'],
+        title: task['title'] || task['content'],
+        description: task['description'] || task['content'],
+        state: task['state'] || task['status'],
+        priority: task['priority'],
+        effort: task['effort'],
+        tags: task['tags'] || []
+      }
+    rescue CommandExecutor::CommandError, JSON::ParserError
+      nil
+    end
+
+    def find_next_file_task
+      # Simple file-based task system fallback
+      task_dir = File.join(EnhanceSwarm.root, 'tasks', 'backlog')
+      return nil unless Dir.exist?(task_dir)
+
+      task_files = Dir.glob(File.join(task_dir, '*.md')).sort
+      return nil if task_files.empty?
+
+      task_file = task_files.first
+      content = File.read(task_file)
+
+      {
+        id: File.basename(task_file, '.md'),
+        title: extract_title(content),
+        description: content,
+        state: 'backlog',
+        priority: 'medium',
+        effort: 4,
+        tags: []
+      }
+    end
+
+    def find_file_task(task_id)
+      %w[backlog active completed].each do |state|
+        task_file = File.join(EnhanceSwarm.root, 'tasks', state, "#{task_id}.md")
+        next unless File.exist?(task_file)
+
+        content = File.read(task_file)
+        return {
+          id: task_id,
+          title: extract_title(content),
+          description: content,
+          state: state,
+          priority: 'medium',
+          effort: 4,
+          tags: []
+        }
+      end
+      nil
+    end
+
+    def list_file_tasks(state)
+      tasks = []
+
+      states = state == 'all' ? %w[backlog active completed] : [state]
+
+      states.each do |s|
+        task_dir = File.join(EnhanceSwarm.root, 'tasks', s)
+        next unless Dir.exist?(task_dir)
+
+        Dir.glob(File.join(task_dir, '*.md')).each do |file|
+          content = File.read(file)
+          tasks << {
+            id: File.basename(file, '.md'),
+            title: extract_title(content),
+            description: content,
+            state: s,
+            priority: 'medium',
+            effort: 4,
+            tags: []
+          }
+        end
+      end
+
+      tasks
+    end
+
+    def extract_title(content)
+      # Try to extract first heading or first line
+      if (match = content.match(/^#\s+(.+)$/))
+        match[1]
+      else
+        content.lines.first&.strip || 'Untitled Task'
+      end
+    end
+  end
+end

data/lib/enhance_swarm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EnhanceSwarm
+  VERSION = '1.0.0'
+end