coplan-engine 0.2.0 → 1.0.0

data/app/javascript/controllers/coplan/text_selection_controller.js

@@ -6,8 +6,14 @@ export default class extends Controller {
 
   connect() {
     this.selectedText = null
-    this.contentTarget.addEventListener("mouseup", this.handleMouseUp.bind(this))
-    document.addEventListener("mousedown", this.handleDocumentMouseDown.bind(this))
+    this._activeMark = null
+    this._activePopover = null
+    this._boundHandleMouseUp = this.handleMouseUp.bind(this)
+    this._boundHandleDocumentMouseDown = this.handleDocumentMouseDown.bind(this)
+    this._handleScroll = this._handleScroll.bind(this)
+    this.contentTarget.addEventListener("mouseup", this._boundHandleMouseUp)
+    document.addEventListener("mousedown", this._boundHandleDocumentMouseDown)
+    window.addEventListener("scroll", this._handleScroll, { passive: true })
     this.highlightAnchors()
 
     // Watch for broadcast-appended threads and re-highlight
@@ -18,8 +24,9 @@ export default class extends Controller {
   }
 
   disconnect() {
-    this.contentTarget.removeEventListener("mouseup", this.handleMouseUp.bind(this))
-    document.removeEventListener("mousedown", this.handleDocumentMouseDown.bind(this))
+    this.contentTarget.removeEventListener("mouseup", this._boundHandleMouseUp)
+    document.removeEventListener("mousedown", this._boundHandleDocumentMouseDown)
+    window.removeEventListener("scroll", this._handleScroll)
     if (this._threadsObserver) {
       this._threadsObserver.disconnect()
       this._threadsObserver = null
@@ -31,6 +38,20 @@ export default class extends Controller {
     setTimeout(() => this.checkSelection(event), 10)
   }
 
+  dismiss(event) {
+    // Close the comment form if it's visible
+    if (this.hasFormTarget && this.formTarget.style.display === "block") {
+      event.preventDefault()
+      this.hideAndResetForm()
+      return
+    }
+    // Close the selection popover if it's visible
+    if (this.hasPopoverTarget && this.popoverTarget.style.display === "block") {
+      event.preventDefault()
+      this.popoverTarget.style.display = "none"
+    }
+  }
+
   handleDocumentMouseDown(event) {
     // Hide popover if clicking outside it
     if (this.hasPopoverTarget && !this.popoverTarget.contains(event.target)) {
@@ -40,17 +61,36 @@ export default class extends Controller {
 
   checkSelection(event) {
     const selection = window.getSelection()
-    const text = selection.toString().trim()
 
-    if (text.length < 3) {
-      this.popoverTarget.style.display = "none"
+    if (!selection.rangeCount) return
+    const range = selection.getRangeAt(0)
+
+    // Make sure at least part of the selection is within the content area.
+    // Whole-line selections (e.g. triple-click) can set commonAncestorContainer
+    // to a parent element above contentTarget, so we check start/end individually.
+    const startInContent = this.contentTarget.contains(range.startContainer)
+    const endInContent = this.contentTarget.contains(range.endContainer)
+    if (!startInContent) {
       return
     }
 
-    // Make sure selection is within the content area
-    if (!selection.rangeCount) return
-    const range = selection.getRangeAt(0)
-    if (!this.contentTarget.contains(range.commonAncestorContainer)) {
+    // Clamp the range to the last rendered markdown element, not the
+    // content wrapper's lastChild (which is a hidden popover/form control).
+    if (startInContent && !endInContent) {
+      const clampTarget = this.hasPopoverTarget
+        ? this.popoverTarget.previousElementSibling || this.popoverTarget.previousSibling
+        : this.contentTarget.lastChild
+      if (clampTarget) range.setEndAfter(clampTarget)
+    }
+
+    // Extract text after clamping so it only contains content-area text.
+    // Normalize tabs to spaces — browser selections across table cells
+    // produce tab-separated text, but the server matches against
+    // space-separated plain text extracted from the markdown AST.
+    const text = selection.toString().replace(/\t/g, " ").trim()
+
+    if (text.length < 3) {
+      this.popoverTarget.style.display = "none"
       return
     }
 
@@ -111,7 +151,10 @@ export default class extends Controller {
     if (event.detail.success) {
       const form = event.target
       const textarea = form.querySelector("textarea")
-      if (textarea) textarea.value = ""
+      if (textarea) {
+        textarea.value = ""
+        textarea.blur()
+      }
     }
   }
 
@@ -155,40 +198,49 @@ export default class extends Controller {
     const popover = document.getElementById(`${threadId}_popover`)
     if (!popover) return
 
-    // Position the popover near the clicked element
     const trigger = event.currentTarget
-    const triggerRect = trigger.getBoundingClientRect()
 
-    // Hide visually while positioning to prevent flash
     popover.style.visibility = "hidden"
     popover.showPopover()
+    this._positionPopoverAtMark(popover, trigger)
+    popover.style.visibility = "visible"
+
+    this._activeMark = trigger
+    this._activePopover = popover
+  }
+
+  _handleScroll() {
+    if (!this._activeMark || !this._activePopover) return
+    try {
+      if (!this._activePopover.matches(":popover-open")) {
+        this._activeMark = null
+        this._activePopover = null
+        return
+      }
+    } catch { return }
+    this._positionPopoverAtMark(this._activePopover, this._activeMark)
+  }
 
-    // Position after showing (popover needs to be in top layer first)
+  _positionPopoverAtMark(popover, mark) {
+    const markRect = mark.getBoundingClientRect()
     const popoverRect = popover.getBoundingClientRect()
     const viewportWidth = window.innerWidth
     const viewportHeight = window.innerHeight
 
-    // Default: right of the content area, aligned with the trigger
-    let top = triggerRect.top
-    let left = triggerRect.right + 12
+    let top = markRect.top
+    let left = markRect.right + 12
 
-    // If it would overflow right, position to the left
     if (left + popoverRect.width > viewportWidth - 16) {
-      left = triggerRect.left - popoverRect.width - 12
+      left = markRect.left - popoverRect.width - 12
     }
-
-    // If it would overflow bottom, shift up
     if (top + popoverRect.height > viewportHeight - 16) {
       top = viewportHeight - popoverRect.height - 16
     }
-
-    // Ensure it doesn't go outside viewport
     if (top < 16) top = 16
     if (left < 16) left = 16
 
     popover.style.top = `${top}px`
     popover.style.left = `${left}px`
-    popover.style.visibility = "visible"
   }
 
   extractContext(range, selectedText) {
@@ -218,15 +270,22 @@ export default class extends Controller {
 
   // Computes the 1-based occurrence number of the selected text in the DOM content.
   // This is sent to the server so resolve_anchor_position picks the right match.
+  // Uses whitespace-normalized matching for consistency with findAndHighlight.
   computeOccurrence(range, text) {
     const offset = this.getSelectionOffset(range)
     const fullText = this.contentTarget.textContent
+    const { normText, origIndices } = this._buildNormalizedMap(fullText)
+    const normSearch = this._normalizeWhitespace(text)
+
+    // Map the DOM offset to the normalized string offset
+    let normOffset = origIndices.findIndex(orig => orig >= offset)
+    if (normOffset === -1) normOffset = normText.length
 
     let count = 0
     let pos = -1
-    while ((pos = fullText.indexOf(text, pos + 1)) !== -1) {
+    while ((pos = normText.indexOf(normSearch, pos + 1)) !== -1) {
       count++
-      if (pos >= offset) return count
+      if (pos >= normOffset) return count
     }
     return count > 0 ? count : 1
   }
@@ -276,21 +335,31 @@ export default class extends Controller {
       if (anchor && anchor.length > 0) {
         const isOpen = status === "pending" || status === "todo"
         const statusClass = isOpen ? "anchor-highlight--open" : "anchor-highlight--resolved"
-        const mark = this.findAndHighlight(anchor, occurrence, `anchor-highlight ${statusClass}`)
-
-        if (mark && threadId) {
-          // Make highlight clickable to open popover
-          mark.dataset.threadId = threadId
-          mark.style.cursor = "pointer"
-          mark.addEventListener("click", (e) => this.openThreadPopover(e))
-
-          // Create margin dot
+        const specificClass = isOpen ? `anchor-highlight--${status}` : ""
+        const classes = `anchor-highlight ${statusClass} ${specificClass}`.trim()
+        const marks = this.findAndHighlightAll(anchor, occurrence, classes)
+
+        if (marks.length > 0 && threadId) {
+          // Make all highlight marks clickable to open popover.
+          // If a mark is shared with another thread, keep the first
+          // thread's binding — the margin dot still provides access.
+          marks.forEach(mark => {
+            if (!mark.dataset.threadId) {
+              mark.dataset.threadId = threadId
+              mark.style.cursor = "pointer"
+              mark.addEventListener("click", (e) => this.openThreadPopover(e))
+            }
+          })
+
+          // Create margin dot aligned to the first mark
           if (this.hasMarginTarget) {
-            this.createMarginDot(mark, threadId, status)
+            this.createMarginDot(marks[0], threadId, status)
           }
         }
       }
     })
+
+    this.element.dispatchEvent(new CustomEvent("coplan:anchors-updated", { bubbles: true }))
   }
 
   createMarginDot(highlightMark, threadId, status) {
@@ -300,44 +369,106 @@ export default class extends Controller {
 
     const dot = document.createElement("button")
     const isOpen = status === "pending" || status === "todo"
-    dot.className = `margin-dot margin-dot--${isOpen ? "open" : "resolved"}`
+    const openClass = isOpen ? `margin-dot--open margin-dot--${status}` : "margin-dot--resolved"
+    dot.className = `margin-dot ${openClass}`
     dot.style.top = `${markRect.top - marginRect.top}px`
     dot.dataset.threadId = threadId
     dot.addEventListener("click", (e) => this.openThreadPopover(e))
-    dot.title = `${status} comment`
+    dot.setAttribute("aria-label", `${status} comment`)
 
     this.marginTarget.appendChild(dot)
   }
 
   // Find and highlight the Nth occurrence of text in the rendered DOM.
   // Uses the occurrence index from server-side positional data.
+  // Performs whitespace-normalized matching so that anchor text captured
+  // from browser selections (which may differ in whitespace from the DOM
+  // textContent, e.g. tabs in table selections) can still be located.
   findAndHighlight(text, occurrence, className) {
     const fullText = this.fullText
-    let targetIndex = -1
 
-    if (occurrence !== undefined && occurrence !== "") {
-      const occurrenceNum = parseInt(occurrence, 10)
-      if (!isNaN(occurrenceNum)) {
-        targetIndex = this.findNthOccurrence(fullText, text, occurrenceNum)
+    if (occurrence === undefined || occurrence === "") return null
+
+    const occurrenceNum = parseInt(occurrence, 10)
+    if (isNaN(occurrenceNum)) return null
+
+    const match = this._findNthNormalized(fullText, text, occurrenceNum)
+    if (!match) return null
+
+    return this.highlightAtIndex(match.startIndex, match.matchLength, className)
+  }
+
+  // Like findAndHighlight but returns all created/reused marks (for multi-cell spans).
+  findAndHighlightAll(text, occurrence, className) {
+    const fullText = this.fullText
+
+    if (occurrence === undefined || occurrence === "") return []
+
+    const occurrenceNum = parseInt(occurrence, 10)
+    if (isNaN(occurrenceNum)) return []
+
+    const match = this._findNthNormalized(fullText, text, occurrenceNum)
+    if (!match) return []
+
+    return this.highlightAtIndexAll(match.startIndex, match.matchLength, className)
+  }
+
+  // Collapses runs of whitespace (spaces, tabs, newlines) into single spaces.
+  _normalizeWhitespace(str) {
+    return str.replace(/\s+/g, " ")
+  }
+
+  // Builds a whitespace-normalized version of `text` with a parallel array
+  // mapping each normalized position back to its original index.
+  // Returns { normText, origIndices } where origIndices[i] is the original
+  // index of the character at normalized position i.
+  _buildNormalizedMap(text) {
+    let normText = ""
+    const origIndices = []
+    let inWhitespace = false
+
+    for (let i = 0; i < text.length; i++) {
+      if (/\s/.test(text[i])) {
+        if (!inWhitespace) {
+          normText += " "
+          origIndices.push(i)
+          inWhitespace = true
+        }
+      } else {
+        normText += text[i]
+        origIndices.push(i)
+        inWhitespace = false
       }
     }
 
-    if (targetIndex === -1) return null
-
-    return this.highlightAtIndex(targetIndex, text.length, className)
+    return { normText, origIndices }
   }
 
-  findNthOccurrence(text, search, n) {
+  // Finds the Nth occurrence of `search` in `text` using whitespace-normalized
+  // matching. Returns { startIndex, matchLength } in the *original* text,
+  // or null if not found.
+  _findNthNormalized(text, search, n) {
+    const { normText, origIndices } = this._buildNormalizedMap(text)
+    const normSearch = this._normalizeWhitespace(search)
+
     let pos = -1
     for (let i = 0; i <= n; i++) {
-      pos = text.indexOf(search, pos + 1)
-      if (pos === -1) return -1
+      pos = normText.indexOf(normSearch, pos + 1)
+      if (pos === -1) return null
     }
-    return pos
+
+    const origStart = origIndices[pos]
+    const origEnd = origIndices[pos + normSearch.length - 1] + 1
+    return { startIndex: origStart, matchLength: origEnd - origStart }
   }
 
   highlightAtIndex(startIndex, length, className) {
-    if (startIndex < 0 || length <= 0) return null
+    const marks = this.highlightAtIndexAll(startIndex, length, className)
+    return marks[0] || null
+  }
+
+  highlightAtIndexAll(startIndex, length, className) {
+    if (startIndex < 0 || length <= 0) return []
 
     const walker = document.createTreeWalker(
       this.contentTarget,
@@ -355,7 +486,7 @@ export default class extends Controller {
     }
 
     const matchEnd = startIndex + length
-    let firstHighlighted = null
+    const marks = []
 
     for (let i = 0; i < textNodes.length; i++) {
       const tn = textNodes[i]
@@ -364,9 +495,25 @@ export default class extends Controller {
       if (nodeEnd <= startIndex) continue
       if (tn.start >= matchEnd) break
 
+      // Skip structural whitespace text nodes inside table elements —
+      // wrapping these in <mark> produces invalid HTML and breaks table layout.
+      const parentTag = tn.node.parentElement?.tagName
+      if (parentTag && /^(TABLE|THEAD|TBODY|TFOOT|TR)$/.test(parentTag)) continue
+
       const localStart = Math.max(0, startIndex - tn.start)
       const localEnd = Math.min(tn.node.textContent.length, matchEnd - tn.start)
 
+      // Skip zero-length ranges (e.g. from text node splits by prior highlights)
+      if (localEnd <= localStart) continue
+
+      // If the text is already inside a highlight mark (from another thread
+      // anchored to the same text), reuse that mark instead of nesting.
+      const existingMark = tn.node.parentElement?.closest("mark.anchor-highlight")
+      if (existingMark) {
+        if (!marks.includes(existingMark)) marks.push(existingMark)
+        continue
+      }
+
       const range = document.createRange()
       range.setStart(tn.node, localStart)
       range.setEnd(tn.node, localEnd)
@@ -375,9 +522,9 @@ export default class extends Controller {
       mark.className = className
       range.surroundContents(mark)
 
-      if (!firstHighlighted) firstHighlighted = mark
+      marks.push(mark)
     }
 
-    return firstHighlighted
+    return marks
   }
 }

data/app/models/coplan/comment.rb

@@ -11,6 +11,10 @@ module CoPlan
 
     after_create_commit :notify_plan_author, if: :first_comment_in_thread?
 
+    def agent?
+      agent_name.present? || author_type.in?(%w[local_agent cloud_persona])
+    end
+
     private
 
     def first_comment_in_thread?

data/app/models/coplan/comment_thread.rb

@@ -112,23 +112,25 @@ module CoPlan
       !out_of_date
     end
 
-    # Returns the 0-based occurrence index of anchor_text in the raw markdown,
-    # computed from anchor_start. The frontend uses this to find the correct
-    # occurrence in the rendered DOM text instead of relying on context matching.
+    # Returns the 0-based occurrence index of anchor_text in the rendered
+    # (stripped) content, computed from anchor_start. The frontend uses this
+    # to find the correct occurrence in the rendered DOM text.
     def anchor_occurrence_index
       return nil unless anchored? && anchor_start.present?
 
       content = plan.current_content
       return nil unless content.present?
 
-      count = 0
-      pos = 0
-      while (idx = content.index(anchor_text, pos))
-        break if idx >= anchor_start
-        count += 1
-        pos = idx + 1
-      end
-      count
+      stripped, pos_map = self.class.strip_markdown(content)
+      # Map raw anchor_start to its position in the stripped string.
+      # Use >= to find the closest valid position if anchor_start falls
+      # on a stripped formatting character.
+      stripped_start = pos_map.index { |raw_idx| raw_idx >= anchor_start }
+      return nil if stripped_start.nil?
+
+      normalized_anchor = anchor_text.gsub("\t", " ")
+      ranges = find_all_occurrences(stripped, normalized_anchor)
+      ranges.index { |s, _| s >= stripped_start } || 0
     end
 
     def anchor_context_with_highlight(chars: 100)
@@ -147,6 +149,10 @@ module CoPlan
       "#{before}**#{anchor}**#{after}"
     end
 
+    def self.strip_markdown(content)
+      Plans::MarkdownTextExtractor.call(content)
+    end
+
     private
 
     def resolve_anchor_position
@@ -158,11 +164,26 @@ module CoPlan
       occurrence = self.anchor_occurrence || 1
       return if occurrence < 1
 
-      ranges = []
-      start_pos = 0
-      while (idx = content.index(anchor_text, start_pos))
-        ranges << [idx, idx + anchor_text.length]
-        start_pos = idx + anchor_text.length
+      # First, try an exact match against the raw markdown.
+      ranges = find_all_occurrences(content, anchor_text)
+
+      # If no exact match, the selected text may span markdown formatting
+      # (e.g. DOM text "Hello me you" vs raw "Hello `me` you", or table
+      # cell text without pipe delimiters). Parse the markdown AST to
+      # extract plain text with source position mapping.
+      if ranges.empty?
+        stripped, pos_map = self.class.strip_markdown(content)
+        # Normalize tabs to spaces — browser selections across table cells
+        # produce tab-separated text, but the stripped markdown uses spaces.
+        normalized_anchor = anchor_text.gsub("\t", " ")
+        stripped_ranges = find_all_occurrences(stripped, normalized_anchor)
+
+        ranges = stripped_ranges.map do |s, e|
+          raw_start = first_real_pos(pos_map, s, :forward)
+          raw_end = first_real_pos(pos_map, e - 1, :backward)
+          next nil unless raw_start && raw_end
+          [raw_start, raw_end + 1]
+        end.compact
       end
 
       if ranges.length >= occurrence
@@ -172,5 +193,26 @@ module CoPlan
         self.anchor_revision = plan.current_revision
       end
     end
+
+    # Finds the nearest non-sentinel (-1) position in the pos_map,
+    # scanning forward or backward from the given index.
+    def first_real_pos(pos_map, idx, direction)
+      step = direction == :forward ? 1 : -1
+      while idx >= 0 && idx < pos_map.length
+        return pos_map[idx] if pos_map[idx] >= 0
+        idx += step
+      end
+      nil
+    end
+
+    def find_all_occurrences(text, search)
+      ranges = []
+      start_pos = 0
+      while (idx = text.index(search, start_pos))
+        ranges << [idx, idx + search.length]
+        start_pos = idx + search.length
+      end
+      ranges
+    end
   end
 end

data/app/models/coplan/plan.rb

@@ -10,6 +10,7 @@ module CoPlan
     has_many :comment_threads, dependent: :destroy
     has_many :edit_sessions, dependent: :destroy
     has_one :edit_lease, dependent: :destroy
+    has_many :plan_viewers, dependent: :destroy
 
     after_initialize { self.tags ||= [] }
     after_initialize { self.metadata ||= {} }

data/app/models/coplan/plan_viewer.rb

@@ -0,0 +1,26 @@
+module CoPlan
+  class PlanViewer < ApplicationRecord
+    STALE_THRESHOLD = 45.seconds
+
+    belongs_to :plan
+    belongs_to :user, class_name: "CoPlan::User"
+
+    scope :active, -> { where(last_seen_at: STALE_THRESHOLD.ago..) }
+
+    def self.track(plan:, user:)
+      record = find_or_initialize_by(plan: plan, user: user)
+      record.update!(last_seen_at: Time.current)
+      record
+    rescue ActiveRecord::RecordNotUnique
+      retry
+    end
+
+    def self.expire(plan:, user:)
+      where(plan: plan, user: user).update_all(last_seen_at: STALE_THRESHOLD.ago - 1.second)
+    end
+
+    def self.active_viewers_for(plan)
+      active.where(plan: plan).joins(:user).includes(:user).order("coplan_users.name").map(&:user)
+    end
+  end
+end

data/app/services/coplan/plans/apply_operations.rb

@@ -21,6 +21,8 @@ module CoPlan
             apply_insert_under_heading(op, index)
           when "delete_paragraph_containing"
             apply_delete_paragraph_containing(op, index)
+          when "replace_section"
+            apply_replace_section(op, index)
           else
             raise OperationError, "Operation #{index}: unknown op '#{op["op"]}'"
           end
@@ -103,6 +105,47 @@ module CoPlan
         applied_data
       end
 
+      def apply_replace_section(op, index)
+        heading = op["heading"]
+        new_content = op["new_content"]
+
+        raise OperationError, "Operation #{index}: replace_section requires 'heading'" if heading.blank?
+        raise OperationError, "Operation #{index}: replace_section requires 'new_content'" if new_content.nil?
+
+        range = if op.key?("_pre_resolved_ranges")
+          op["_pre_resolved_ranges"][0]
+        else
+          Plans::PositionResolver.call(content: @content, operation: op).ranges[0]
+        end
+
+        # For body-only replacements (include_heading: false), ensure
+        # newlines separate the heading from new content and new content
+        # from the next section.
+        include_heading = op.fetch("include_heading", true)
+        include_heading = include_heading != false && include_heading != "false"
+        effective_content = new_content
+        if !include_heading && range[0] == range[1]
+          # Prepend newline if heading line doesn't end with one
+          if range[0] > 0 && @content[range[0] - 1] != "\n"
+            effective_content = "\n#{effective_content}"
+          end
+          # Append newline if next content starts without one
+          after = @content[range[1]]
+          if after && after != "\n" && !effective_content.end_with?("\n")
+            effective_content = "#{effective_content}\n"
+          end
+        end
+
+        @content = @content[0...range[0]] + effective_content + @content[range[1]..]
+
+        delta = effective_content.length - (range[1] - range[0])
+        applied_data = op.except("_pre_resolved_ranges")
+        applied_data["resolved_range"] = range
+        applied_data["new_range"] = [range[0], range[0] + effective_content.length]
+        applied_data["delta"] = delta
+        applied_data
+      end
+
       def apply_delete_paragraph_containing(op, index)
         needle = op["needle"]
 

data/app/services/coplan/plans/commit_session.rb

@@ -65,7 +65,7 @@ module CoPlan
             rebased_ops = []
             @session.operations_json.each do |op_data|
               op_data = op_data.transform_keys(&:to_s)
-              semantic_keys = %w[op old_text new_text heading content needle occurrence replace_all count]
+              semantic_keys = %w[op old_text new_text heading content needle occurrence replace_all count new_content include_heading]
               semantic_op = op_data.slice(*semantic_keys)
 
               if op_data["resolved_range"]
@@ -179,6 +179,31 @@ module CoPlan
 
           raise SessionConflictError,
             "Paragraph at target position no longer contains '#{op_data["needle"]}'"
+        when "replace_section"
+          return unless op_data["heading"]
+          include_heading = op_data.fetch("include_heading", true)
+          include_heading = include_heading != false && include_heading != "false"
+
+          if include_heading
+            first_line_end = content.index("\n", range[0]) || range[1]
+            first_line = content[range[0]...[first_line_end, range[1]].min]
+            return if first_line&.rstrip == op_data["heading"]&.rstrip
+
+            raise SessionConflictError,
+              "Section heading changed at target position. Expected '#{op_data["heading"]}' " \
+              "but found '#{first_line}'"
+          else
+            search_pos = range[0]
+            search_pos -= 1 while search_pos > 0 && content[search_pos - 1] == "\n"
+            heading_line_end = search_pos
+            heading_line_start = search_pos > 0 ? (content.rindex("\n", search_pos - 1) || -1) + 1 : 0
+            heading_text = content[heading_line_start...heading_line_end]
+            return if heading_text == op_data["heading"]
+
+            raise SessionConflictError,
+              "Section heading before target position changed. Expected '#{op_data["heading"]}' " \
+              "but found '#{heading_text}'"
+          end
         end
       end
     end