aidp 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95269030b5c3fe91c2cfb6e29066a4f37afbcf1903e930a377ec02dd1e8a738c
-  data.tar.gz: 6c343d45e804a73751c99e0e63491703c1eb9ba18fb2acf4e828198e774c2c92
+  metadata.gz: 220c03eda20360cfa8b954bc578b15fe766742e849037539f1a1f9c794310569
+  data.tar.gz: 0fa8cc7ff18ab1ee66c11f187df4554f84504d4713322f089427b9d921de5420
 SHA512:
-  metadata.gz: dc54a6f0b9424c18ebdd8e6df75e77f0f233db98dd59543a9dd6152eacd835d8820c437ccd220c3dbcfb43cf91bfeb47e40ce415773e8cd0e24783770b2ac033
-  data.tar.gz: f89cf387121e7edc3c384cead9369bc6ae5be97e639969fa036978a249779152ccd7a50832897be97d7fd04f4083ccf744e23e93c1117c6ed5d1cc7d8529615d
+  metadata.gz: 772f8bc2099fce5b1d8ff0c9d8567382281851b7d3a283eb0aa847ad92d5f420b9aff91c702424df89cf6570cc59cfe35dacc8baf7df60b0d019cd1dfc97ceea
+  data.tar.gz: 1bad64d70c87752e7416bbad5558ff9cab2e67902b2e461bbd1ad946a4659951949ea4f6c0642a2424d81a6119e405f9208647e5d7c229d13626fc9f0774bae7

data/lib/aidp/cli/terminal_io.rb

@@ -51,8 +51,11 @@ module Aidp
           interrupt: :exit
         )
 
-        # Read line with full readline support (Ctrl-A, Ctrl-E, Ctrl-W, etc.)
-        result = reader.read_line(prompt, default: default || "")
+        # TTY::Reader#read_line does not support a :default keyword; we emulate fallback
+        result = reader.read_line(prompt)
+        if (result.nil? || result.chomp.empty?) && !default.nil?
+          return default
+        end
         result&.chomp
       rescue TTY::Reader::InputInterrupt
         raise Interrupt

data/lib/aidp/execute/agent_signal_parser.rb

@@ -16,6 +16,26 @@ module Aidp
         nil
       end
 
+      # Parse task filing signals from agent output
+      # Returns array of task hashes with description, priority, and tags
+      def self.parse_task_filing(output)
+        return [] unless output
+
+        tasks = []
+        # Pattern: File task: "description" [priority: high|medium|low] [tags: tag1,tag2]
+        pattern = /File\s+task:\s*"([^"]+)"(?:\s+priority:\s*(high|medium|low))?(?:\s+tags:\s*([^\s]+))?/i
+
+        output.to_s.scan(pattern).each do |description, priority, tags|
+          tasks << {
+            description: description.strip,
+            priority: (priority || "medium").downcase.to_sym,
+            tags: tags ? tags.split(",").map(&:strip) : []
+          }
+        end
+
+        tasks
+      end
+
       def self.normalize_token(raw)
         return nil if raw.nil? || raw.empty?
 

data/lib/aidp/execute/persistent_tasklist.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "securerandom"
+require "fileutils"
+
+module Aidp
+  module Execute
+    # Task struct for persistent tasklist entries
+    Task = Struct.new(
+      :id,
+      :description,
+      :status,
+      :priority,
+      :created_at,
+      :updated_at,
+      :session,
+      :discovered_during,
+      :started_at,
+      :completed_at,
+      :abandoned_at,
+      :abandoned_reason,
+      :tags,
+      keyword_init: true
+    ) do
+      def to_h
+        super.compact
+      end
+    end
+
+    # Persistent tasklist for tracking tasks across sessions
+    # Uses append-only JSONL format for git-friendly storage
+    class PersistentTasklist
+      attr_reader :project_dir, :file_path
+
+      class TaskNotFoundError < StandardError; end
+      class InvalidTaskError < StandardError; end
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+        @file_path = File.join(project_dir, ".aidp", "tasklist.jsonl")
+        ensure_file_exists
+      end
+
+      # Create a new task
+      def create(description, priority: :medium, session: nil, discovered_during: nil, tags: [])
+        validate_description!(description)
+        validate_priority!(priority)
+
+        task = Task.new(
+          id: generate_id,
+          description: description.strip,
+          status: :pending,
+          priority: priority,
+          created_at: Time.now,
+          updated_at: Time.now,
+          session: session,
+          discovered_during: discovered_during,
+          tags: Array(tags)
+        )
+
+        append_task(task)
+        Aidp.log_debug("tasklist", "Created task", task_id: task.id, description: task.description)
+        task
+      end
+
+      # Update task status
+      def update_status(task_id, new_status, reason: nil)
+        validate_status!(new_status)
+        task = find(task_id)
+        raise TaskNotFoundError, "Task not found: #{task_id}" unless task
+
+        task.status = new_status
+        task.updated_at = Time.now
+
+        case new_status
+        when :in_progress
+          task.started_at ||= Time.now
+        when :done
+          task.completed_at = Time.now
+        when :abandoned
+          task.abandoned_at = Time.now
+          task.abandoned_reason = reason
+        end
+
+        append_task(task)
+        Aidp.log_debug("tasklist", "Updated task status", task_id: task.id, status: new_status)
+        task
+      end
+
+      # Query tasks with optional filters
+      def all(status: nil, priority: nil, since: nil, tags: nil)
+        tasks = load_latest_tasks
+
+        tasks = tasks.select { |t| t.status == status } if status
+        tasks = tasks.select { |t| t.priority == priority } if priority
+        tasks = tasks.select { |t| t.created_at >= since } if since
+        tasks = tasks.select { |t| (Array(t.tags) & Array(tags)).any? } if tags && !tags.empty?
+
+        tasks.sort_by(&:created_at).reverse
+      end
+
+      # Find single task by ID
+      def find(task_id)
+        all.find { |t| t.id == task_id }
+      end
+
+      # Query pending tasks (common operation)
+      def pending
+        all(status: :pending)
+      end
+
+      # Query in-progress tasks
+      def in_progress
+        all(status: :in_progress)
+      end
+
+      # Count tasks by status
+      def counts
+        tasks = load_latest_tasks
+        {
+          total: tasks.size,
+          pending: tasks.count { |t| t.status == :pending },
+          in_progress: tasks.count { |t| t.status == :in_progress },
+          done: tasks.count { |t| t.status == :done },
+          abandoned: tasks.count { |t| t.status == :abandoned }
+        }
+      end
+
+      private
+
+      VALID_STATUSES = [:pending, :in_progress, :done, :abandoned].freeze
+      VALID_PRIORITIES = [:high, :medium, :low].freeze
+
+      def append_task(task)
+        File.open(@file_path, "a") do |f|
+          f.puts serialize_task(task)
+        end
+      end
+
+      def load_latest_tasks
+        return [] unless File.exist?(@file_path)
+
+        tasks_by_id = {}
+
+        File.readlines(@file_path).each_with_index do |line, index|
+          next if line.strip.empty?
+
+          begin
+            data = JSON.parse(line.strip, symbolize_names: true)
+            task = deserialize_task(data)
+            tasks_by_id[task.id] = task
+          rescue JSON::ParserError => e
+            Aidp.log_warn("tasklist", "Skipping malformed JSONL line", line_number: index + 1, error: e.message)
+            next
+          rescue => e
+            Aidp.log_warn("tasklist", "Error loading task", line_number: index + 1, error: e.message)
+            next
+          end
+        end
+
+        tasks_by_id.values
+      end
+
+      def serialize_task(task)
+        hash = task.to_h
+        # Convert Time objects to ISO8601 strings
+        hash[:created_at] = hash[:created_at].iso8601 if hash[:created_at]
+        hash[:updated_at] = hash[:updated_at].iso8601 if hash[:updated_at]
+        hash[:started_at] = hash[:started_at].iso8601 if hash[:started_at]
+        hash[:completed_at] = hash[:completed_at].iso8601 if hash[:completed_at]
+        hash[:abandoned_at] = hash[:abandoned_at].iso8601 if hash[:abandoned_at]
+        JSON.generate(hash)
+      end
+
+      def deserialize_task(data)
+        Task.new(**data.merge(
+          status: data[:status]&.to_sym,
+          priority: data[:priority]&.to_sym,
+          created_at: parse_time(data[:created_at]),
+          updated_at: parse_time(data[:updated_at]),
+          started_at: parse_time(data[:started_at]),
+          completed_at: parse_time(data[:completed_at]),
+          abandoned_at: parse_time(data[:abandoned_at]),
+          tags: Array(data[:tags])
+        ))
+      end
+
+      def parse_time(time_string)
+        return nil if time_string.nil?
+        Time.parse(time_string)
+      rescue ArgumentError
+        nil
+      end
+
+      def generate_id
+        "task_#{Time.now.to_i}_#{SecureRandom.hex(4)}"
+      end
+
+      def ensure_file_exists
+        FileUtils.mkdir_p(File.dirname(@file_path))
+        FileUtils.touch(@file_path) unless File.exist?(@file_path)
+      end
+
+      def validate_description!(description)
+        raise InvalidTaskError, "Description cannot be empty" if description.nil? || description.strip.empty?
+        raise InvalidTaskError, "Description too long (max 200 chars)" if description.length > 200
+      end
+
+      def validate_priority!(priority)
+        raise InvalidTaskError, "Invalid priority: #{priority}" unless VALID_PRIORITIES.include?(priority)
+      end
+
+      def validate_status!(status)
+        raise InvalidTaskError, "Invalid status: #{status}" unless VALID_STATUSES.include?(status)
+      end
+    end
+  end
+end

data/lib/aidp/execute/repl_macros.rb

@@ -293,6 +293,12 @@ module Aidp
             usage: "/prompt <explain|stats|expand|reset>",
             example: "/prompt explain",
             handler: method(:cmd_prompt)
+          },
+          "/tasks" => {
+            description: "Manage persistent tasklist (cross-session task tracking)",
+            usage: "/tasks <list|show|done|abandon|stats> [args]",
+            example: "/tasks list pending",
+            handler: method(:cmd_tasks)
           }
         }
       end
@@ -2037,6 +2043,164 @@ module Aidp
         }
       end
 
+      # Manage persistent tasklist
+      def cmd_tasks(args)
+        tasklist = PersistentTasklist.new(@project_dir)
+        subcommand = args[0]
+
+        case subcommand
+        when "list", nil
+          cmd_tasks_list(tasklist, args[1])
+        when "show"
+          cmd_tasks_show(tasklist, args[1])
+        when "done"
+          cmd_tasks_done(tasklist, args[1])
+        when "abandon"
+          cmd_tasks_abandon(tasklist, args[1], args[2..]&.join(" "))
+        when "stats"
+          cmd_tasks_stats(tasklist)
+        else
+          {
+            success: false,
+            message: "Unknown subcommand: #{subcommand}. Use: list, show, done, abandon, stats",
+            action: :none
+          }
+        end
+      rescue => e
+        Aidp.log_error("repl_macros", "Tasks command failed", error: e.message)
+        {success: false, message: "Error: #{e.message}", action: :none}
+      end
+
+      private
+
+      # List tasks with optional status filter
+      def cmd_tasks_list(tasklist, status_filter = nil)
+        status = status_filter&.to_sym
+        tasks = status ? tasklist.all(status: status) : tasklist.all
+
+        if tasks.empty?
+          message = status ? "No #{status} tasks found." : "No tasks found."
+          return {success: true, message: message, action: :display}
+        end
+
+        # Group by status
+        by_status = tasks.group_by(&:status)
+        output = []
+
+        [:pending, :in_progress, :done, :abandoned].each do |st|
+          next unless by_status[st]
+          next if status && st != status # Skip if filtering by specific status
+
+          output << ""
+          output << "#{st.to_s.upcase.tr("_", " ")} (#{by_status[st].size})"
+          output << "=" * 50
+
+          by_status[st].each do |task|
+            priority_icon = case task.priority
+            when :high then "⚠️ "
+            when :medium then "○ "
+            when :low then "· "
+            end
+
+            age = ((Time.now - task.created_at) / 86400).to_i
+            age_str = (age > 0) ? " (#{age}d ago)" : " (today)"
+
+            output << "  #{priority_icon}[#{task.id}] #{task.description}#{age_str}"
+          end
+        end
+
+        {
+          success: true,
+          message: output.join("\n"),
+          action: :display
+        }
+      end
+
+      # Show detailed information about a specific task
+      def cmd_tasks_show(tasklist, task_id)
+        return {success: false, message: "Usage: /tasks show <task_id>", action: :none} unless task_id
+
+        task = tasklist.find(task_id)
+        unless task
+          return {success: false, message: "Task not found: #{task_id}", action: :none}
+        end
+
+        output = []
+        output << ""
+        output << "Task Details:"
+        output << "=" * 50
+        output << "ID:          #{task.id}"
+        output << "Description: #{task.description}"
+        output << "Status:      #{task.status}"
+        output << "Priority:    #{task.priority}"
+        output << "Created:     #{task.created_at}"
+        output << "Updated:     #{task.updated_at}"
+        output << "Session:     #{task.session}" if task.session
+        output << "Context:     #{task.discovered_during}" if task.discovered_during
+        output << "Started:     #{task.started_at}" if task.started_at
+        output << "Completed:   #{task.completed_at}" if task.completed_at
+        output << "Abandoned:   #{task.abandoned_at} (#{task.abandoned_reason})" if task.abandoned_at
+        output << "Tags:        #{task.tags.join(", ")}" if task.tags&.any?
+
+        {
+          success: true,
+          message: output.join("\n"),
+          action: :display
+        }
+      end
+
+      # Mark a task as done
+      def cmd_tasks_done(tasklist, task_id)
+        return {success: false, message: "Usage: /tasks done <task_id>", action: :none} unless task_id
+
+        task = tasklist.update_status(task_id, :done)
+        {
+          success: true,
+          message: "✓ Task marked as done: #{task.description}",
+          action: :display
+        }
+      rescue PersistentTasklist::TaskNotFoundError
+        {success: false, message: "Task not found: #{task_id}", action: :none}
+      end
+
+      # Abandon a task with optional reason
+      def cmd_tasks_abandon(tasklist, task_id, reason = nil)
+        return {success: false, message: "Usage: /tasks abandon <task_id> [reason]", action: :none} unless task_id
+
+        task = tasklist.update_status(task_id, :abandoned, reason: reason)
+        message = "✗ Task abandoned: #{task.description}"
+        message += " (Reason: #{reason})" if reason
+
+        {
+          success: true,
+          message: message,
+          action: :display
+        }
+      rescue PersistentTasklist::TaskNotFoundError
+        {success: false, message: "Task not found: #{task_id}", action: :none}
+      end
+
+      # Show task statistics
+      def cmd_tasks_stats(tasklist)
+        counts = tasklist.counts
+
+        output = []
+        output << ""
+        output << "Task Statistics:"
+        output << "=" * 50
+        output << "Total:       #{counts[:total]}"
+        output << "Pending:     #{counts[:pending]}"
+        output << "In Progress: #{counts[:in_progress]}"
+        output << "Done:        #{counts[:done]}"
+        output << "Abandoned:   #{counts[:abandoned]}"
+
+        {
+          success: true,
+          message: output.join("\n"),
+          action: :display
+        }
+      end
+
       private
 
       # Load configuration for prompt commands

data/lib/aidp/execute/work_loop_runner.rb

@@ -51,6 +51,7 @@ module Aidp
         @checkpoint = Checkpoint.new(project_dir)
         @checkpoint_display = CheckpointDisplay.new
         @guard_policy = GuardPolicy.new(project_dir, config.guards_config)
+        @persistent_tasklist = PersistentTasklist.new(project_dir)
         @iteration_count = 0
         @step_name = nil
         @options = options
@@ -74,6 +75,7 @@ module Aidp
         display_message("  Flow: Deterministic ↔ Agentic with fix-forward core", type: :info)
 
         display_guard_policy_status
+        display_pending_tasks
 
         @unit_scheduler = WorkLoopUnitScheduler.new(units_config)
         base_context = context.dup
@@ -148,6 +150,9 @@ module Aidp
           transition_to(:apply_patch)
           agent_result = apply_patch
 
+          # Process agent output for task filing signals
+          process_task_filing(agent_result)
+
           transition_to(:test)
           test_results = @test_runner.run_tests
           lint_results = @test_runner.run_linters
@@ -776,6 +781,55 @@ module Aidp
         display_message("")
       end
 
+      # Display pending tasks from persistent tasklist
+      def display_pending_tasks
+        pending_tasks = @persistent_tasklist.pending
+        return if pending_tasks.empty?
+
+        display_message("\n📋 Pending Tasks from Previous Sessions:", type: :info)
+
+        # Show up to 5 most recent pending tasks
+        pending_tasks.take(5).each do |task|
+          priority_icon = case task.priority
+          when :high then "⚠️ "
+          when :medium then "○ "
+          when :low then "· "
+          end
+
+          age = ((Time.now - task.created_at) / 86400).to_i
+          age_str = (age > 0) ? " (#{age}d ago)" : " (today)"
+
+          display_message("  #{priority_icon}#{task.description}#{age_str}", type: :info)
+        end
+
+        if pending_tasks.size > 5
+          display_message("  ... and #{pending_tasks.size - 5} more. Use /tasks list to see all", type: :info)
+        end
+
+        display_message("")
+      end
+
+      # Process agent output for task filing signals
+      def process_task_filing(agent_result)
+        return unless agent_result && agent_result[:output]
+
+        filed_tasks = AgentSignalParser.parse_task_filing(agent_result[:output])
+        return if filed_tasks.empty?
+
+        filed_tasks.each do |task_data|
+          task = @persistent_tasklist.create(
+            task_data[:description],
+            priority: task_data[:priority],
+            session: @step_name,
+            discovered_during: "#{@step_name} iteration #{@iteration_count}",
+            tags: task_data[:tags]
+          )
+
+          Aidp.log_info("tasklist", "Filed new task from agent", task_id: task.id, description: task.description)
+          display_message("📋 Filed task: #{task.description} (#{task.id})", type: :info)
+        end
+      end
+
       # Validate changes against guard policy
       # Returns validation result with errors if any
       def validate_guard_policy(changed_files = [])

data/lib/aidp/version.rb

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

data/lib/aidp.rb

@@ -59,6 +59,7 @@ require_relative "aidp/execute/checkpoint"
 require_relative "aidp/execute/checkpoint_display"
 require_relative "aidp/execute/work_loop_state"
 require_relative "aidp/execute/instruction_queue"
+require_relative "aidp/execute/persistent_tasklist"
 require_relative "aidp/execute/async_work_loop_runner"
 require_relative "aidp/execute/interactive_repl"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -271,6 +271,7 @@ files:
 - lib/aidp/execute/guard_policy.rb
 - lib/aidp/execute/instruction_queue.rb
 - lib/aidp/execute/interactive_repl.rb
+- lib/aidp/execute/persistent_tasklist.rb
 - lib/aidp/execute/progress.rb
 - lib/aidp/execute/prompt_manager.rb
 - lib/aidp/execute/repl_macros.rb