docsmith 0.1.0 → 0.2.0

data/lib/docsmith/diff/renderers/base.rb

@@ -6,56 +6,156 @@ require "cgi"
 module Docsmith
   module Diff
     module Renderers
-      # Line-level diff renderer using diff-lcs.
-      # Handles all content types (markdown, html, json) for Phase 2.
-      # Register content-type-specific renderers via Renderers::Registry when needed.
+      # Line-level diff renderer, and the base for the format-aware parsers.
+      #
+      # Subclasses override #tokenize only. All grouping, offset arithmetic, and
+      # HTML rendering lives here, so every content type produces the same edit
+      # structure and only the token boundaries differ.
+      #
+      # An edit is a contiguous run of changes collapsed into one entry:
+      #
+      #   { type: :replace,
+      #     old:  { start: 0, end: 11, line: 1, column: 1, text: "my document" },
+      #     new:  { start: 0, end: 30, line: 1, column: 1, text: "<h1>..." } }
+      #
+      # Both sides are always present. A pure insertion carries a zero-width old
+      # span at the insertion point; a pure deletion a zero-width new span. Every
+      # edit therefore has identical keys, and offsets on the two sides never
+      # share a coordinate space.
+      #
+      # `text` is sliced straight out of the source between the run's offsets, so
+      # whitespace the tokenizer discarded is preserved verbatim and both
+      # documents round-trip exactly.
       class Base
-        # Computes line-level changes between two content strings.
+        # Actions that consume a token from the old side / the new side.
+        OLD_SIDE = %w[- !].freeze
+        NEW_SIDE = %w[+ !].freeze
+
+        # Splits content into [text, start_offset] pairs. Lines here, excluding
+        # the newline itself. Override in subclasses for other content types.
+        #
+        # The newline is deliberately not part of the token: including it made
+        # appending a line report the *previous* line as changed, because that
+        # line gained a trailing newline. Empty lines are preserved as empty
+        # tokens so that blank-line changes are still detected.
+        #
+        # @param content [String]
+        # @return [Array<Array(String, Integer)>]
+        def tokenize(content)
+          offset = 0
+          content.to_s.split("\n", -1).map do |line|
+            token = [line, offset]
+            offset += line.length + 1
+            token
+          end
+        end
+
+        # Computes grouped edits between two content strings.
         #
         # @param old_content [String]
         # @param new_content [String]
-        # @return [Array<Hash>] change hashes with :type, :line, and content fields
+        # @return [Array<Hash>] edit hashes with :type, :old and :new
         def compute(old_content, new_content)
-          old_lines = old_content.split("\n", -1)
-          new_lines = new_content.split("\n", -1)
-          changes   = []
-
-          ::Diff::LCS.sdiff(old_lines, new_lines).each do |hunk|
-            case hunk.action
-            when "+"
-              changes << { type: :addition, line: hunk.new_position + 1, content: hunk.new_element.to_s }
-            when "-"
-              changes << { type: :deletion, line: hunk.old_position + 1, content: hunk.old_element.to_s }
-            when "!"
-              changes << {
-                type:        :modification,
-                line:        hunk.old_position + 1,
-                old_content: hunk.old_element.to_s,
-                new_content: hunk.new_element.to_s
-              }
+          old_content = old_content.to_s
+          new_content = new_content.to_s
+          old_tokens  = tokenize(old_content)
+          new_tokens  = tokenize(new_content)
+
+          edits = []
+          run   = []
+
+          ::Diff::LCS.sdiff(old_tokens.map(&:first), new_tokens.map(&:first)).each do |hunk|
+            if hunk.action == "="
+              edits << build_edit(run, old_tokens, new_tokens, old_content, new_content) unless run.empty?
+              run = []
+            else
+              run << hunk
             end
           end
+          edits << build_edit(run, old_tokens, new_tokens, old_content, new_content) unless run.empty?
 
-          changes
+          edits
         end
 
-        # Renders a change array as an HTML diff representation.
+        # Renders grouped edits as an HTML diff representation.
         #
-        # @param changes [Array<Hash>]
+        # @param edits [Array<Hash>]
         # @return [String] HTML string
-        def render_html(changes)
-          lines = changes.map do |change|
-            case change[:type]
-            when :addition
-              %(<ins class="docsmith-addition">#{CGI.escapeHTML(change[:content])}</ins>)
-            when :deletion
-              %(<del class="docsmith-deletion">#{CGI.escapeHTML(change[:content])}</del>)
-            when :modification
-              %(<del class="docsmith-deletion">#{CGI.escapeHTML(change[:old_content])}</del><ins class="docsmith-addition">#{CGI.escapeHTML(change[:new_content])}</ins>)
+        def render_html(edits)
+          lines = edits.map do |edit|
+            case edit[:type]
+            when :insert  then insertion(edit[:new][:text])
+            when :delete  then deletion(edit[:old][:text])
+            when :replace then deletion(edit[:old][:text]) + insertion(edit[:new][:text])
             end
           end
           %(<div class="docsmith-diff">#{lines.join("\n")}</div>)
         end
+
+        private
+
+        def insertion(text)
+          %(<ins class="docsmith-addition">#{CGI.escapeHTML(text.to_s)}</ins>)
+        end
+
+        def deletion(text)
+          %(<del class="docsmith-deletion">#{CGI.escapeHTML(text.to_s)}</del>)
+        end
+
+        # Collects every match with its start offset. scan sets Regexp.last_match
+        # per iteration when a block is given.
+        def scan_with_offsets(content, pattern)
+          matches = []
+          content.to_s.scan(pattern) { matches << [::Regexp.last_match(0), ::Regexp.last_match.begin(0)] }
+          matches
+        end
+
+        def build_edit(run, old_tokens, new_tokens, old_content, new_content)
+          old_indexes = run.select { |h| OLD_SIDE.include?(h.action) }.map(&:old_position)
+          new_indexes = run.select { |h| NEW_SIDE.include?(h.action) }.map(&:new_position)
+
+          {
+            type: edit_type(old_indexes, new_indexes),
+            old:  span(old_content, old_tokens, old_indexes, run.first.old_position),
+            new:  span(new_content, new_tokens, new_indexes, run.first.new_position)
+          }
+        end
+
+        def edit_type(old_indexes, new_indexes)
+          return :insert if old_indexes.empty?
+          return :delete if new_indexes.empty?
+
+          :replace
+        end
+
+        # @param indexes [Array<Integer>] token indexes this run touches on this side
+        # @param fallback_index [Integer] token index to anchor a zero-width span at
+        def span(content, tokens, indexes, fallback_index)
+          if indexes.empty?
+            start  = token_start(tokens, fallback_index, content)
+            finish = start
+          else
+            last_text, last_start = tokens[indexes.last]
+            start  = tokens[indexes.first][1]
+            finish = last_start + last_text.length
+          end
+
+          line, column = line_and_column(content, start)
+          { start: start, end: finish, line: line, column: column, text: content[start...finish].to_s }
+        end
+
+        # Character offset a token begins at; end of content when past the last token.
+        def token_start(tokens, index, content)
+          index < tokens.length ? tokens[index][1] : content.length
+        end
+
+        # 1-indexed line and column for a character offset.
+        def line_and_column(content, offset)
+          prefix       = content[0, offset].to_s
+          last_newline = prefix.rindex("\n")
+
+          [prefix.count("\n") + 1, last_newline.nil? ? offset + 1 : offset - last_newline]
+        end
       end
     end
   end

data/lib/docsmith/diff/result.rb

@@ -13,7 +13,12 @@ module Docsmith
       attr_reader :from_version
       # @return [Integer] version_number of the to (newer) version
       attr_reader :to_version
-      # @return [Array<Hash>] change hashes produced by Renderers::Base#compute
+      # Grouped edits produced by Renderers::Base#compute. Symbol-keyed mirror of
+      # the serialized form: each entry is
+      # { type: :insert|:delete|:replace, old: {...span}, new: {...span} }
+      # where a span is { start:, end:, line:, column:, text: }.
+      #
+      # @return [Array<Hash>]
       attr_reader :changes
 
       # @param content_type [String]
@@ -27,14 +32,34 @@ module Docsmith
         @changes      = changes
       end
 
-      # @return [Integer] number of added lines
-      def additions
-        changes.count { |c| c[:type] == :addition }
+      # @return [Integer] number of pure insertions
+      def insertions
+        changes.count { |c| c[:type] == :insert }
       end
 
-      # @return [Integer] number of deleted lines
+      # @return [Integer] number of pure deletions
       def deletions
-        changes.count { |c| c[:type] == :deletion }
+        changes.count { |c| c[:type] == :delete }
+      end
+
+      # @return [Integer] number of replacements (an old span became a new one)
+      def replacements
+        changes.count { |c| c[:type] == :replace }
+      end
+
+      # Edit counts by kind. insertions and deletions are pure; a replacement is
+      # counted once rather than as one of each, so a rewritten document never
+      # reports 0/0 alongside a non-empty changes array. For git-style totals, add
+      # replacements to either side.
+      #
+      # @return [Hash] string-keyed counts
+      def stats
+        {
+          "insertions"   => insertions,
+          "deletions"    => deletions,
+          "replacements" => replacements,
+          "total"        => changes.length
+        }
       end
 
       # @return [String] HTML diff representation
@@ -42,35 +67,55 @@ module Docsmith
         Renderers::Registry.for(content_type).new.render_html(changes)
       end
 
-      # @return [String] JSON diff representation matching the documented schema
-      def to_json(*)
+      # The canonical JSON representation, and the single source of truth for it.
+      #
+      # Defining as_json is what makes nesting work: ActiveSupport calls it for
+      # `render json: { diff: result }`, `[result].to_json`, and JSON.generate.
+      # Without it those fell through to Object#as_json (instance_values), which
+      # silently dropped "stats" and emitted "line" instead of "position".
+      #
+      # @param options [Hash, nil] accepted for API compatibility; unused
+      # @return [Hash] string-keyed, JSON-ready
+      def as_json(options = nil) # rubocop:disable Lint/UnusedMethodArgument
         {
-          content_type: content_type,
-          from_version: from_version,
-          to_version:   to_version,
-          stats:        { additions: additions, deletions: deletions },
-          changes:      changes.map { |c| serialize_change(c) }
-        }.to_json
+          "schema_version" => Docsmith::JSON_SCHEMA_VERSION,
+          "content_type"   => content_type,
+          "from_version"   => from_version,
+          "to_version"     => to_version,
+          "stats"          => stats,
+          "changes"        => changes.map { |c| serialize_change(c) }
+        }
+      end
+
+      # Args are forwarded so JSON.pretty_generate indents a nested Result
+      # instead of splicing it in as one compact line.
+      #
+      # @return [String] JSON diff representation matching the documented schema
+      def to_json(*args)
+        as_json.to_json(*args)
       end
 
       private
 
+      # Every edit serializes to the same keys, and the two sides never share a
+      # coordinate space. An absent side is a zero-width span marking the point
+      # where text was inserted into, or removed from, that document.
       def serialize_change(change)
-        case change[:type]
-        when :addition
-          { type: "addition", position: { line: change[:line] }, content: change[:content] }
-        when :deletion
-          { type: "deletion", position: { line: change[:line] }, content: change[:content] }
-        when :modification
-          {
-            type:        "modification",
-            position:    { line: change[:line] },
-            old_content: change[:old_content],
-            new_content: change[:new_content]
-          }
-        else
-          change.transform_keys(&:to_s)
-        end
+        {
+          "type" => change[:type].to_s,
+          "old"  => serialize_span(change[:old]),
+          "new"  => serialize_span(change[:new])
+        }
+      end
+
+      def serialize_span(span)
+        {
+          "start"  => span[:start],
+          "end"    => span[:end],
+          "line"   => span[:line],
+          "column" => span[:column],
+          "text"   => span[:text]
+        }
       end
     end
   end

data/lib/docsmith/document_version.rb

@@ -46,5 +46,20 @@ module Docsmith
       else raise ArgumentError, "Unknown render format: #{format}. Supported: :html, :json"
       end
     end
+
+    # The JSON export envelope as a Hash, for embedding in a larger API response
+    # without a JSON round-trip. Same shape as render(:json).
+    #
+    # Note this is deliberately NOT `as_json`. DocumentVersion is an
+    # ActiveRecord::Base, and overriding as_json would silently change what
+    # `render json: @version` returns for every app already relying on standard
+    # attribute serialization.
+    #
+    # @param options [Hash] :include_parsed adds "data" with the parsed document
+    # @return [Hash] string-keyed, JSON-ready
+    # @raise [Docsmith::InvalidJsonContent] if :include_parsed is set and content does not parse
+    def export(**options)
+      Rendering::JsonRenderer.new.to_h(self, **options)
+    end
   end
 end

data/lib/docsmith/errors.rb

@@ -15,4 +15,14 @@ module Docsmith
 
   # Raised when tag_version! is called with a name already used on this document.
   class TagAlreadyExists < Error; end
+
+  # Raised when a JSON export is asked to parse content (include_parsed: true)
+  # on a version whose content_type is "json" but whose content is not valid JSON.
+  # The default export path never parses, so it never raises this.
+  class InvalidJsonContent < Error; end
+
+  # Raised when configuration.html_sanitizer is neither nil, :unsafe_raw, nor callable.
+  # Fails loudly rather than falling back, so a misconfigured sanitizer can never
+  # silently degrade into rendering untrusted HTML verbatim.
+  class InvalidHtmlSanitizer < Error; end
 end

data/lib/docsmith/rendering/html_renderer.rb

@@ -8,6 +8,7 @@ module Docsmith
     # Renders a DocumentVersion's content as an HTML string.
     # Markdown is shown pre-formatted (no external gem dependency).
     # JSON is pretty-printed inside a pre block.
+    # html content passes through Docsmith.configuration.html_sanitizer.
     # Subclass and override #render to plug in a markdown gem (e.g. redcarpet).
     class HtmlRenderer
       # @param version [Docsmith::DocumentVersion]
@@ -19,7 +20,7 @@ module Docsmith
 
         case content_type
         when "html"
-          content
+          sanitize_html(content)
         when "markdown"
           "<pre class=\"docsmith-markdown\">#{CGI.escapeHTML(content)}</pre>"
         when "json"
@@ -31,6 +32,30 @@ module Docsmith
       rescue JSON::ParserError
         "<pre>#{CGI.escapeHTML(content)}</pre>"
       end
+
+      private
+
+      # Stored HTML is untrusted input. Returning it verbatim is stored XSS, so
+      # that only happens when the host app explicitly asks for it.
+      # See Docsmith::Configuration#html_sanitizer for the three modes.
+      #
+      # @param content [String] raw stored HTML
+      # @return [String]
+      def sanitize_html(content)
+        sanitizer = Docsmith.configuration.html_sanitizer
+
+        case sanitizer
+        when :unsafe_raw       then content
+        when nil               then "<pre class=\"docsmith-html\">#{CGI.escapeHTML(content)}</pre>"
+        else
+          raise Docsmith::InvalidHtmlSanitizer, <<~MSG unless sanitizer.respond_to?(:call)
+            html_sanitizer must respond to #call, or be :unsafe_raw or nil.
+            Got: #{sanitizer.inspect}
+          MSG
+
+          sanitizer.call(content).to_s
+        end
+      end
     end
   end
 end

data/lib/docsmith/rendering/json_renderer.rb

@@ -4,25 +4,72 @@ require "json"
 
 module Docsmith
   module Rendering
-    # Renders a DocumentVersion's content as a JSON string.
-    # For json content_type: re-parses and pretty-prints.
-    # For other types: wraps content in a JSON envelope.
+    # Renders a DocumentVersion as a JSON export envelope.
+    #
+    # One shape for every content_type. Before 0.2.0 this returned two
+    # incompatible schemas — a bare pretty-printed document for content_type
+    # "json", an envelope for everything else — so no client could parse it
+    # generically.
+    #
+    # "content" is always the exact stored string, byte for byte. This is a
+    # versioning gem: an export that re-formatted the snapshot would not match
+    # what was versioned, and a client diffing two exports locally would get
+    # different results than the gem's own diff.
+    #
+    # Pass include_parsed: true to additionally receive the parsed document under
+    # "data". That is the only code path that parses, so the default export
+    # cannot fail on malformed content.
     class JsonRenderer
       # @param version [Docsmith::DocumentVersion]
-      # @param options [Hash] unused in Phase 2
-      # @return [String] JSON representation of the version content
-      def render(version, **options)
-        content      = version.content.to_s
-        content_type = version.content_type.to_s
-
-        case content_type
-        when "json"
-          JSON.pretty_generate(JSON.parse(content))
-        else
-          { content_type: content_type, content: content }.to_json
-        end
-      rescue JSON::ParserError
-        { content_type: content_type, content: content, error: "invalid_json" }.to_json
+      # @param include_parsed [Boolean] add "data" with the parsed document (json only)
+      # @return [String] JSON representation of the version
+      def render(version, include_parsed: false, **_options)
+        to_h(version, include_parsed: include_parsed).to_json
+      end
+
+      # The canonical envelope, and the single source of truth for its shape.
+      #
+      # author is emitted as type/id only. The gem cannot know the host app's
+      # author class, which fields it exposes, or which of them are personal
+      # data, so it never serializes the record itself.
+      #
+      # @param version [Docsmith::DocumentVersion]
+      # @param include_parsed [Boolean]
+      # @return [Hash] string-keyed, JSON-ready
+      # @raise [Docsmith::InvalidJsonContent] if include_parsed is set and content does not parse
+      def to_h(version, include_parsed: false, **_options)
+        envelope = {
+          "schema_version" => Docsmith::JSON_SCHEMA_VERSION,
+          "document_id"    => version.document_id,
+          "version_number" => version.version_number,
+          "content_type"   => version.content_type.to_s,
+          "content"        => version.content.to_s,
+          "change_summary" => version.change_summary,
+          "author"         => author_for(version),
+          "metadata"       => version.metadata,
+          "created_at"     => version.created_at&.utc&.iso8601(3)
+        }
+
+        return envelope unless include_parsed && envelope["content_type"] == "json"
+
+        envelope.merge("data" => parse(envelope["content"], version))
+      end
+
+      private
+
+      # @return [Hash, nil]
+      def author_for(version)
+        return nil if version.author_type.nil? && version.author_id.nil?
+
+        { "type" => version.author_type, "id" => version.author_id }
+      end
+
+      def parse(content, version)
+        JSON.parse(content)
+      rescue JSON::ParserError => e
+        raise Docsmith::InvalidJsonContent,
+              "version #{version.version_number} of document #{version.document_id} " \
+              "has content_type \"json\" but its content does not parse: #{e.message}"
       end
     end
   end

data/lib/docsmith/version.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
 module Docsmith
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
+
+  # Wire-format version for every JSON export the gem produces, emitted as the
+  # "schema_version" key. Independent of VERSION: it changes only when the shape
+  # of an export changes, so third-party clients can branch on it instead of
+  # sniffing for keys or pinning a gem version.
+  JSON_SCHEMA_VERSION = 1
 end

data/lib/generators/docsmith/install/install_generator.rb

@@ -12,7 +12,12 @@ module Docsmith
 
       desc "Creates the Docsmith migration and initializer."
 
-      def create_migration
+      # NOTE: do not name this `create_migration`. Rails::Generators::Migration
+      # defines create_migration(destination, data, config) and migration_template
+      # calls it internally, so a same-named zero-arg action method shadows it and
+      # the generator dies with "wrong number of arguments (given 3, expected 0)".
+      # That is what happened in 0.1.0.
+      def create_migration_file
         migration_template(
           "create_docsmith_tables.rb.erb",
           "db/migrate/create_docsmith_tables.rb"
@@ -22,6 +27,23 @@ module Docsmith
       def create_initializer
         template "docsmith_initializer.rb.erb", "config/initializers/docsmith.rb"
       end
+
+      private
+
+      # Column type for JSON payload columns, chosen per adapter.
+      # PostgreSQL gets :jsonb (indexable); every other adapter gets :json,
+      # which MySQL and SQLite both support and which casts to Hash the same way.
+      # Reads the db config rather than the connection so generation works offline.
+      #
+      # Matches /postg/ rather than a "postgresql" prefix so PostgreSQL-derived
+      # adapters (postgis, postgresql_makara) still get jsonb.
+      #
+      # @return [String]
+      def json_column_type
+        ActiveRecord::Base.connection_db_config.adapter.to_s.match?(/postg/i) ? "jsonb" : "json"
+      rescue StandardError
+        "json"
+      end
     end
   end
 end

data/lib/generators/docsmith/install/templates/create_docsmith_tables.rb.erb

@@ -10,7 +10,7 @@ class CreateDocsmithTables < ActiveRecord::Migration[<%= ActiveRecord::Migration
       t.datetime :last_versioned_at
       t.string   :subject_type
       t.bigint   :subject_id
-      t.jsonb    :metadata,           null: false, default: {}
+      t.<%= json_column_type %>    :metadata,           null: false, default: {}
       t.timestamps
     end
     add_index :docsmith_documents, %i[subject_type subject_id]
@@ -23,7 +23,7 @@ class CreateDocsmithTables < ActiveRecord::Migration[<%= ActiveRecord::Migration
       t.string     :author_type
       t.bigint     :author_id
       t.string     :change_summary
-      t.jsonb      :metadata,       null: false, default: {}
+      t.<%= json_column_type %>      :metadata,       null: false, default: {}
       t.datetime   :created_at,     null: false
     end
     add_index :docsmith_versions, %i[document_id version_number], unique: true
@@ -48,7 +48,7 @@ class CreateDocsmithTables < ActiveRecord::Migration[<%= ActiveRecord::Migration
       t.bigint   :author_id
       t.text     :body,              null: false
       t.string   :anchor_type,       null: false, default: "document"
-      t.jsonb    :anchor_data,       null: false, default: {}
+      t.<%= json_column_type %>    :anchor_data,       null: false, default: {}
       t.boolean  :resolved,          null: false, default: false
       t.string   :resolved_by_type
       t.bigint   :resolved_by_id

data/lib/generators/docsmith/install/templates/docsmith_initializer.rb.erb

@@ -10,7 +10,19 @@ Docsmith.configure do |config|
   # config.max_versions             = nil            # gem default: nil (unlimited)
   # config.content_extractor        = nil            # example: ->(record) { record.body.to_html }
   # config.table_prefix             = "docsmith"     # gem default: "docsmith"
-  # config.diff_context_lines       = 3
+  #
+  # How version.render(:html) treats stored HTML content.
+  #
+  # Stored HTML is untrusted input — rendering it verbatim is stored XSS if any
+  # of it came from a user. Docsmith ships no sanitizer, because a safe one needs
+  # a real HTML parser and that would break the zero-system-dependency promise.
+  # Left unset, html content is ESCAPED: safe, and obvious enough that you notice.
+  #
+  # Rails already bundles a sanitizer via ActionView, so opting in is one line:
+  # config.html_sanitizer = ->(html) { Rails::HTML5::SafeListSanitizer.new.sanitize(html) }
+  #
+  # Only for HTML you generate yourself and fully trust:
+  # config.html_sanitizer = :unsafe_raw
   #
   # Event hooks (fires synchronously before AS::Notifications):
   # config.on(:version_created)  { |event| Rails.logger.info "v#{event.version.version_number} saved" }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: docsmith
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - swastik009
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-12 00:00:00.000000000 Z
+date: 2026-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -124,18 +138,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".rspec_status"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - USAGE.md
-- docs/superpowers/plans/2026-04-01-docsmith-full-plan.md
-- docs/superpowers/plans/2026-04-08-parsers-remove-branches-docs.md
-- docs/superpowers/specs/2026-04-01-docsmith-phase1-design.md
-- docsmith_spec.md
 - lib/docsmith.rb
 - lib/docsmith/auto_save.rb
 - lib/docsmith/comments/anchor.rb
@@ -173,7 +181,7 @@ licenses:
 metadata:
   homepage_uri: https://www.altcipher.com
   source_code_uri: https://github.com/swastik009/docsmith
-  changelog_uri: https://github.com/swastik009/docsmith/blob/main/CHANGELOG.md
+  changelog_uri: https://github.com/swastik009/docsmith/blob/master/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths: