aidp 0.44.0 → 0.46.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d898c7dea670e05503b8777e0907e0d0f975d398fd3cf80d9ddc659e8806070c
-  data.tar.gz: c25d8e50f56ce0e89f93c3e5fea9d4fb0ca6d540c19ac5fd3d2710d38be57290
+  metadata.gz: 5efad8256d463a17afb3037a0648f87575b1468b1a87cc97ca9498f6bfe58d30
+  data.tar.gz: 709c073b1fb9202e0c5b6af353677dce774dccd6f885d0b90021d769fff9aa56
 SHA512:
-  metadata.gz: ec307da67468acc15043f72c0295f443a7650a4312d1767f12629fbf582d02354a76cf2476081a313cb434c48eb63f5ec06d6d7d90f39d00d972342725d0dbe5
-  data.tar.gz: 7bbb9cbfff2543d753b56ca940c19745b0b4678d9e4825c418639c5ec2cbeeac99069de846e75e8c8ef05a8d83b825d13d7e99b056a462e07a89c1f56a2cb96a
+  metadata.gz: 8bd69d797c40548a5b34ebb669ebb6f83504f4286144bef7c34380aa3d5be1bee3c14d3472a3a1b4477896ca330abdcbee318abb80cbfbf08846bca2ea65d17d
+  data.tar.gz: a5f2baa7b258fbf34810d4849171f47627fe2c3f30df747a134b0f60de8bc88f0a7ea7099c60909c770e698545853802671213e35fa3c7955bbfd5668b817b1b

data/lib/aidp/cli/devcontainer_commands.rb

@@ -58,6 +58,7 @@ module Aidp
 
         parser = Aidp::Setup::Devcontainer::Parser.new(@project_dir)
         existing_config = parser.devcontainer_exists? ? parser.parse : nil
+        existing_comments = existing_config ? parser.comments : {}
         devcontainer_path = parser.detect || default_devcontainer_path
 
         # Load configuration
@@ -112,7 +113,7 @@ module Aidp
         end
 
         # Write devcontainer.json
-        write_devcontainer(devcontainer_path, final_config)
+        write_devcontainer(devcontainer_path, final_config, comments: existing_comments)
 
         display_message("✅ Devcontainer configuration applied", type: :success)
         display_message("   #{devcontainer_path}", type: :muted)
@@ -191,7 +192,7 @@ module Aidp
         target_path = parser.detect || default_devcontainer_path
 
         # Show what will be restored
-        JSON.parse(File.read(backup_path))
+        Aidp::Setup::Devcontainer::JsoncDocument.parse(File.read(backup_path))
         display_message("📦 Restoring Backup", type: :highlight)
         display_message("   From: #{File.basename(backup_path)}", type: :muted)
         display_message("   To: #{target_path}", type: :muted)
@@ -473,9 +474,14 @@ module Aidp
         end
       end
 
-      def write_devcontainer(path, config)
+      def write_devcontainer(path, config, comments: {})
         FileUtils.mkdir_p(File.dirname(path))
-        File.write(path, JSON.pretty_generate(config))
+        content = if comments.any?
+          Aidp::Setup::Devcontainer::JsoncDocument.dump(config, comments: comments)
+        else
+          JSON.pretty_generate(config)
+        end
+        File.write(path, content)
       end
 
       def default_devcontainer_path

data/lib/aidp/config.rb

@@ -215,10 +215,17 @@ module Aidp
             priority: "Priority",
             skills: "Skills",
             personas: "Personas",
-            blocking: "Blocking"
+            blocking: "Blocking",
+            start_date: "Start Date",
+            target_date: "Target Date",
+            dependencies: "Dependencies",
+            critical_path: "Critical Path"
           },
           auto_create_fields: true,
           sync_interval: 60,
+          prd_path: nil,
+          auto_sync_gantt: false,
+          gantt_format: "auto",
           default_status_values: ["Backlog", "Todo", "In Progress", "In Review", "Done"],
           default_priority_values: ["Low", "Medium", "High", "Critical"]
         },
@@ -512,6 +519,11 @@ module Aidp
         merged[:security] = deep_merge_hash(merged[:security], symbolize_keys(security_section))
       end
 
+      if config[:watch] || config["watch"]
+        watch_section = config[:watch] || config["watch"]
+        merged[:watch] = deep_merge_hash(merged[:watch], symbolize_keys(watch_section))
+      end
+
       merged
     end
 

data/lib/aidp/setup/devcontainer/jsonc_document.rb

@@ -0,0 +1,539 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Aidp
+  module Setup
+    module Devcontainer
+      # Parses and serializes JSON with comments while preserving comment blocks.
+      class JsoncDocument
+        attr_reader :data, :comments
+
+        def self.parse(text)
+          new(text).parse
+        end
+
+        def self.dump(data, comments: {})
+          new(nil).send(:dump, data, comments)
+        end
+
+        def initialize(text)
+          @text = text
+          @index = 0
+          @comments = {}
+        end
+
+        def parse
+          root_comments = consume_comments
+          store_comments([], root_comments, position: :leading) if root_comments.any?
+
+          value = parse_value([])
+          trailing_comments = consume_comments
+          store_comments([], trailing_comments, position: :trailing) if trailing_comments.any?
+          skip_whitespace
+          raise ParseError, "Unexpected trailing content" unless eof?
+
+          @data = value
+          self
+        rescue ParseError => e
+          raise e
+        rescue => e
+          raise ParseError, e.message
+        end
+
+        private
+
+        class ParseError < StandardError; end
+
+        def dump(data, comments)
+          writer = Writer.new(data, comments)
+          writer.dump
+        end
+
+        def parse_value(path)
+          skip_trivia
+
+          case current_char
+          when "{"
+            parse_object(path)
+          when "["
+            parse_array(path)
+          when '"'
+            parse_string
+          when "t", "f", "n"
+            parse_literal
+          else
+            parse_number
+          end
+        end
+
+        def parse_object(path)
+          expect("{")
+          advance while whitespace?(current_char)
+
+          result = {}
+          return result if consume_if("}")
+
+          loop do
+            leading_comments = consume_comments
+            break if consume_if("}")
+
+            key = parse_string
+            skip_trivia
+            expect(":")
+
+            value_path = path + [key]
+            value = parse_value(value_path)
+            inline_comments = consume_inline_comments
+            trailing_comments = consume_comments
+            store_comments(value_path, leading_comments, position: :leading, value: value)
+            store_comments(value_path, inline_comments, position: :inline, value: value)
+            store_comments(value_path, trailing_comments, position: :trailing, value: value)
+            result[key] = value
+
+            skip_trivia
+            break if consume_if("}")
+            expect(",")
+            skip_whitespace
+            break if consume_if("}")
+          end
+
+          result
+        end
+
+        def parse_array(path)
+          expect("[")
+          advance while whitespace?(current_char)
+
+          result = []
+          return result if consume_if("]")
+
+          index = 0
+          loop do
+            leading_comments = consume_comments
+            break if consume_if("]")
+
+            value_path = path + [index]
+            value = parse_value(value_path)
+            inline_comments = consume_inline_comments
+            trailing_comments = consume_comments
+            store_comments(value_path, leading_comments, position: :leading, value: value)
+            store_comments(value_path, inline_comments, position: :inline, value: value)
+            store_comments(value_path, trailing_comments, position: :trailing, value: value)
+            result << value
+
+            index += 1
+            skip_trivia
+            break if consume_if("]")
+            expect(",")
+            skip_whitespace
+            break if consume_if("]")
+          end
+
+          result
+        end
+
+        def parse_string
+          expect('"')
+          chars = +""
+
+          until eof?
+            char = current_char
+
+            case char
+            when '"'
+              advance
+              return chars
+            when "\\"
+              advance
+              chars << parse_escape_sequence
+            else
+              raise ParseError, "Invalid control character in string" if control_character?(char)
+
+              chars << char
+              advance
+            end
+          end
+
+          raise ParseError, "Unterminated string"
+        end
+
+        def parse_escape_sequence
+          raise ParseError, "Unterminated escape sequence" if eof?
+
+          char = current_char
+          advance
+
+          case char
+          when '"', "\\", "/"
+            char
+          when "b" then "\b"
+          when "f" then "\f"
+          when "n" then "\n"
+          when "r" then "\r"
+          when "t" then "\t"
+          when "u"
+            parse_unicode_escape
+          else
+            raise ParseError, "Invalid escape sequence"
+          end
+        end
+
+        def parse_unicode_escape
+          codepoint = read_unicode_codepoint
+          raise ParseError, "Invalid Unicode escape sequence" if low_surrogate?(codepoint)
+
+          return [codepoint].pack("U") unless high_surrogate?(codepoint)
+
+          low_surrogate = read_low_surrogate
+          [combine_surrogate_pair(codepoint, low_surrogate)].pack("U")
+        end
+
+        def read_unicode_codepoint
+          hex = read_chars(4)
+          raise ParseError, "Invalid Unicode escape sequence" unless hex.match?(/\A\h{4}\z/)
+
+          hex.to_i(16)
+        end
+
+        def read_low_surrogate
+          raise ParseError, "Invalid Unicode escape sequence" unless consume_sequence("\\u")
+
+          codepoint = read_unicode_codepoint
+          raise ParseError, "Invalid Unicode escape sequence" unless low_surrogate?(codepoint)
+
+          codepoint
+        end
+
+        def combine_surrogate_pair(high_surrogate, low_surrogate)
+          0x10000 + ((high_surrogate - 0xD800) << 10) + (low_surrogate - 0xDC00)
+        end
+
+        def parse_literal
+          return true if consume_sequence("true")
+          return false if consume_sequence("false")
+          return nil if consume_sequence("null")
+
+          raise ParseError, "Invalid literal"
+        end
+
+        def parse_number
+          match = remaining.match(/\A-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/)
+          raise ParseError, "Invalid number" unless match
+
+          number = match[0]
+          advance_by(number.length)
+          (number.include?(".") || number.match?(/[eE]/)) ? number.to_f : number.to_i
+        end
+
+        def skip_trivia
+          loop do
+            skip_whitespace
+
+            if consume_sequence("//")
+              advance while !eof? && current_char != "\n"
+            elsif consume_sequence("/*")
+              until eof? || consume_sequence("*/")
+                advance
+              end
+              raise ParseError, "Unterminated block comment" if eof?
+            else
+              break
+            end
+          end
+        end
+
+        def skip_whitespace
+          advance while whitespace?(current_char)
+        end
+
+        def consume_comments
+          comments = []
+
+          loop do
+            advance while whitespace?(current_char)
+
+            if consume_sequence("//")
+              comment = +"//"
+              until eof? || current_char == "\n"
+                comment << current_char
+                advance
+              end
+              comments << comment.rstrip
+            elsif consume_sequence("/*")
+              comment = +"/*"
+              until eof?
+                if consume_sequence("*/")
+                  comment << "*/"
+                  comments << comment.rstrip
+                  break
+                end
+
+                comment << current_char
+                advance
+              end
+              raise ParseError, "Unterminated block comment" if eof? && !comments.last&.end_with?("*/")
+            else
+              break
+            end
+          end
+
+          comments
+        end
+
+        def consume_inline_comments
+          start_index = @index
+          advance while horizontal_whitespace?(current_char)
+
+          return [] unless remaining.start_with?("//", "/*")
+
+          comments = consume_comments
+          return comments if comments.any?
+
+          @index = start_index
+          []
+        end
+
+        def store_comments(path, comments, position:, value: nil)
+          return if comments.empty?
+
+          append_comments(comment_key(path, position), comments)
+          store_array_value_comments(path, value, comments, position)
+        end
+
+        def path_key(path)
+          path.map { |part| "#{path_prefix(part)}:#{part}" }.join("\u0000")
+        end
+
+        def path_prefix(part)
+          part.instance_of?(Integer) ? "i" : "s"
+        end
+
+        def append_comments(key, comments)
+          @comments[key] ||= []
+          @comments[key].concat(comments)
+        end
+
+        def comment_key(path, position)
+          "#{path_key(path)}\u0000c:#{position}"
+        end
+
+        def store_array_value_comments(path, value, comments, position)
+          return unless path.last.instance_of?(Integer)
+
+          append_comments(array_value_key(path[0...-1], value, position), comments)
+        end
+
+        def array_value_key(path, value, position)
+          "#{path_key(path)}\u0000a:#{JSON.generate(value)}\u0000c:#{position}"
+        end
+
+        def consume_if(char)
+          return false unless current_char == char
+
+          advance
+          true
+        end
+
+        def expect(char)
+          return if consume_if(char)
+
+          raise ParseError, "Expected #{char}"
+        end
+
+        def consume_sequence(sequence)
+          return false unless remaining.start_with?(sequence)
+
+          advance_by(sequence.length)
+          true
+        end
+
+        def read_chars(count)
+          value = remaining[0, count]
+          raise ParseError, "Unexpected end of input" unless value && value.length == count
+
+          advance_by(count)
+          value
+        end
+
+        def current_char
+          (@text && !eof?) ? @text[@index] : nil
+        end
+
+        def remaining
+          return "" if @text.nil? || eof?
+
+          @text[@index..]
+        end
+
+        def advance
+          @index += 1
+        end
+
+        def advance_by(count)
+          @index += count
+        end
+
+        def eof?
+          @text.nil? || @index >= @text.length
+        end
+
+        def whitespace?(char)
+          char&.match?(/\s/)
+        end
+
+        def horizontal_whitespace?(char)
+          char == " " || char == "\t"
+        end
+
+        def control_character?(char)
+          char.ord < 0x20
+        end
+
+        def high_surrogate?(codepoint)
+          codepoint.between?(0xD800, 0xDBFF)
+        end
+
+        def low_surrogate?(codepoint)
+          codepoint.between?(0xDC00, 0xDFFF)
+        end
+
+        # Serializes JSON while re-inserting preserved comments before values.
+        class Writer
+          def initialize(data, comments)
+            @data = data
+            @comments = comments
+            @output = +""
+            @array_comment_offsets = Hash.new(0)
+          end
+
+          def dump
+            write_comments([], 0, position: :leading)
+            write_value(@data, [])
+            write_root_trailing_comments
+            @output
+          end
+
+          private
+
+          def write_value(value, path, indent = 0)
+            case value
+            when Hash
+              write_object(value, path, indent)
+            when Array
+              write_array(value, path, indent)
+            else
+              @output << JSON.generate(value)
+            end
+          end
+
+          def write_object(hash, path, indent)
+            if hash.empty?
+              @output << "{}"
+              return
+            end
+
+            @output << "{\n"
+            entries = hash.to_a
+
+            entries.each_with_index do |(key, value), index|
+              child_path = path + [key]
+              write_comments(child_path, indent + 2, position: :leading)
+              @output << (" " * (indent + 2))
+              @output << JSON.generate(key)
+              @output << ": "
+              write_value(value, child_path, indent + 2)
+              write_inline_comments(child_path)
+              @output << "," if index < entries.length - 1
+              @output << "\n"
+              write_comments(child_path, indent + 2, position: :trailing)
+            end
+
+            @output << (" " * indent) << "}"
+          end
+
+          def write_array(array, path, indent)
+            if array.empty?
+              @output << "[]"
+              return
+            end
+
+            @output << "[\n"
+            array.each_with_index do |value, index|
+              child_path = path + [index]
+              write_comments(child_path, indent + 2, position: :leading)
+              @output << (" " * (indent + 2))
+              write_value(value, child_path, indent + 2)
+              write_inline_comments(child_path)
+              @output << "," if index < array.length - 1
+              @output << "\n"
+              write_comments(child_path, indent + 2, position: :trailing)
+            end
+
+            @output << (" " * indent) << "]"
+          end
+
+          def write_comments(path, indent, position:)
+            comments_for(path, position).each do |comment|
+              comment.each_line do |line|
+                @output << (" " * indent) << line.rstrip << "\n"
+              end
+            end
+          end
+
+          def write_inline_comments(path)
+            comments_for(path, :inline).each do |comment|
+              @output << " " << comment
+            end
+          end
+
+          def write_root_trailing_comments
+            trailing_comments = comments_for([], :trailing)
+            return if trailing_comments.empty?
+
+            @output << "\n"
+            write_comments([], 0, position: :trailing)
+          end
+
+          def comments_for(path, position)
+            return array_comments_for(path, position) if path.last.instance_of?(Integer)
+
+            @comments[comment_key(path, position)] || []
+          end
+
+          def path_key(path)
+            path.map { |part| "#{path_prefix(part)}:#{part}" }.join("\u0000")
+          end
+
+          def path_prefix(part)
+            part.instance_of?(Integer) ? "i" : "s"
+          end
+
+          def comment_key(path, position)
+            "#{path_key(path)}\u0000c:#{position}"
+          end
+
+          def array_comments_for(path, position)
+            parent_path = path[0...-1]
+            array = @data.dig(*parent_path)
+            return [] unless array.is_a?(Array)
+
+            key = array_value_key(parent_path, array[path.last], position)
+            comments = @comments[key]
+            return [] if comments.nil? || comments.empty?
+
+            offset = @array_comment_offsets[key]
+            return [] if offset >= comments.length
+
+            @array_comment_offsets[key] += 1
+            [comments[offset]]
+          end
+
+          def array_value_key(path, value, position)
+            "#{path_key(path)}\u0000a:#{JSON.generate(value)}\u0000c:#{position}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/setup/devcontainer/parser.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "fileutils"
+require_relative "jsonc_document"
 
 module Aidp
   module Setup
@@ -18,7 +19,7 @@ module Aidp
           "devcontainer.json"
         ].freeze
 
-        attr_reader :project_dir, :devcontainer_path, :config
+        attr_reader :project_dir, :devcontainer_path, :config, :comments
 
         def initialize(project_dir = Dir.pwd)
           @project_dir = project_dir
@@ -61,12 +62,14 @@ module Aidp
 
           begin
             content = File.read(@devcontainer_path)
-            @config = JSON.parse(content)
+            document = JsoncDocument.parse(content)
+            @config = document.data
+            @comments = document.comments
             Aidp.log_debug("devcontainer_parser", "parsed devcontainer",
               features_count: extract_features.size,
               ports_count: extract_ports.size)
             @config
-          rescue JSON::ParserError => e
+          rescue JsoncDocument::ParseError, JSON::ParserError => e
             Aidp.log_error("devcontainer_parser", "invalid JSON", error: e.message, path: @devcontainer_path)
             raise InvalidDevcontainerError, "Invalid JSON in #{@devcontainer_path}: #{e.message}"
           rescue => e

data/lib/aidp/setup/wizard.rb

@@ -2888,6 +2888,7 @@ module Aidp
 
         parser = Devcontainer::Parser.new(project_dir)
         existing = parser.devcontainer_exists? ? parser.parse : nil
+        existing_comments = existing ? parser.comments : {}
 
         generator = Devcontainer::Generator.new(project_dir, @config)
         new_config = generator.generate(wizard_config, existing)
@@ -2907,7 +2908,12 @@ module Aidp
         # Write devcontainer.json
         devcontainer_path = File.join(project_dir, ".devcontainer", "devcontainer.json")
         FileUtils.mkdir_p(File.dirname(devcontainer_path))
-        File.write(devcontainer_path, JSON.pretty_generate(new_config))
+        content = if existing_comments.any?
+          Devcontainer::JsoncDocument.dump(new_config, comments: existing_comments)
+        else
+          JSON.pretty_generate(new_config)
+        end
+        File.write(devcontainer_path, content)
 
         prompt.ok("✅ Generated #{devcontainer_path}")
         Aidp.log_debug(DEVCONTAINER_COMPONENT, "generate.complete",

data/lib/aidp/version.rb

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