ccexport 0.1.0

data/lib/markdown_code_block_parser.rb

@@ -0,0 +1,268 @@
+class MarkdownCodeBlockParser
+  attr_reader :markdown, :matches, :pairs, :blocks
+
+  def initialize(markdown)
+    @markdown = markdown
+    @matches = []
+    @pairs = []
+    @blocks = []
+  end
+
+  def parse
+    find_all_code_blocks
+    pair_code_blocks
+    build_block_structures
+    detect_nesting
+    self
+  end
+
+  private
+
+  def find_all_code_blocks
+    # Find all backtick sequences with their positions
+    pattern = /(^|\n)(```+)([a-zA-Z0-9]*)?/
+
+    @markdown.scan(pattern) do
+      match = Regexp.last_match
+      pos = match.begin(0)
+      backticks = match[2]
+      lang = match[3] unless match[3].nil? || match[3].empty?
+
+      @matches << {
+        pos: pos,
+        ticks: backticks.length,
+        lang: lang,
+        full_match: match[0],
+        index: @matches.length
+      }
+    end
+  end
+
+  def pair_code_blocks
+    stack = []
+
+    @matches.each_with_index do |match, i|
+      # Heuristic 1: If it has a language specifier, it's definitely opening
+      if match[:lang]
+        stack.push(i)
+        next
+      end
+
+      # Heuristic 2: Check if this could be a closing block
+      if !stack.empty? && i > 0
+        last_opener_idx = stack.last
+        last_opener = @matches[last_opener_idx]
+
+        # Get content between them
+        content_start = last_opener[:pos] + last_opener[:full_match].length
+        content_end = match[:pos]
+        content_between = @markdown[content_start...content_end].strip
+
+        # If there's substantial content and tick counts match, likely a pair
+        if content_between.length > 10 && last_opener[:ticks] == match[:ticks]
+          @pairs << [last_opener_idx, i]
+          stack.pop
+          next
+        end
+      end
+
+      # Heuristic 3: Check if this looks like an opening based on what follows
+      if i < @matches.length - 1
+        next_match = @matches[i + 1]
+        content_after_end = next_match ? next_match[:pos] : @markdown.length
+        content_after = @markdown[(match[:pos] + match[:full_match].length)...content_after_end].strip
+
+        # If there's content after that looks like code, this might be opening
+        if !content_after.empty? && !content_after.start_with?('#')
+          stack.push(i)
+          next
+        end
+      end
+
+      # Default: assume it's closing if we have something to close
+      if !stack.empty?
+        # Try to match with the most recent opener with same tick count
+        matched = false
+        stack.reverse_each.with_index do |stack_idx, j|
+          if @matches[stack_idx][:ticks] == match[:ticks]
+            @pairs << [stack_idx, i]
+            stack.delete_at(stack.length - 1 - j)
+            matched = true
+            break
+          end
+        end
+
+        # No matching tick count, close the most recent
+        if !matched
+          @pairs << [stack.last, i]
+          stack.pop
+        end
+      end
+    end
+  end
+
+  def build_block_structures
+    @pairs.each do |start_idx, end_idx|
+      start_match = @matches[start_idx]
+      end_match = @matches[end_idx]
+
+      block = {
+        start_pos: start_match[:pos],
+        end_pos: end_match[:pos] + end_match[:full_match].length,
+        language: start_match[:lang],
+        tick_count: start_match[:ticks],
+        content_start: start_match[:pos] + start_match[:full_match].length,
+        content_end: end_match[:pos],
+        start_match_idx: start_idx,
+        end_match_idx: end_idx
+      }
+
+      # Extract content
+      block[:content] = @markdown[block[:content_start]...block[:content_end]].strip
+
+      @blocks << block
+    end
+  end
+
+  def detect_nesting
+    @blocks.each_with_index do |block, i|
+      block[:nested_blocks] = []
+      block[:depth] = 0
+
+      @blocks.each_with_index do |other, j|
+        next if i == j
+
+        # Check if other is nested inside block
+        if block[:start_pos] < other[:start_pos] && other[:end_pos] < block[:end_pos]
+          block[:nested_blocks] << j
+        end
+
+        # Check if block is nested inside other
+        if other[:start_pos] < block[:start_pos] && block[:end_pos] < other[:end_pos]
+          block[:depth] += 1
+        end
+      end
+    end
+  end
+
+  def escape_nested_blocks
+    # Calculate maximum nesting depth
+    max_depth = @blocks.map { |b| b[:depth] }.max || 0
+
+    # Create a list of modifications to apply
+    modifications = []
+
+    @blocks.each do |block|
+      # Use 3 + (max_depth - depth) backticks
+      # So the outermost uses the most backticks
+      new_tick_count = 3 + (max_depth - block[:depth])
+      old_tick_count = block[:tick_count]
+
+      if new_tick_count != old_tick_count
+        # Record the modification for the opening backticks
+        start_match = @matches[block[:start_match_idx]]
+        modifications << {
+          pos: start_match[:pos],
+          old_text: start_match[:full_match],
+          new_text: start_match[:full_match].gsub('`' * old_tick_count, '`' * new_tick_count)
+        }
+
+        # Record the modification for the closing backticks
+        end_match = @matches[block[:end_match_idx]]
+        modifications << {
+          pos: end_match[:pos],
+          old_text: end_match[:full_match],
+          new_text: end_match[:full_match].gsub('`' * old_tick_count, '`' * new_tick_count)
+        }
+      end
+    end
+
+    # Sort modifications by position (reverse order to maintain positions)
+    modifications.sort_by! { |m| -m[:pos] }
+
+    # Apply modifications
+    result = @markdown.dup
+    modifications.each do |mod|
+      result[mod[:pos], mod[:old_text].length] = mod[:new_text]
+    end
+
+    result
+  end
+
+  public
+  
+  def display_analysis
+    puts "Detected #{@matches.length} code block delimiters"
+    puts "Formed #{@pairs.length} pairs"
+    puts "\nCode blocks found:"
+
+    @blocks.each_with_index do |block, i|
+      puts "\nBlock #{i}:"
+      puts "  Language: #{block[:language] || 'none'}"
+      puts "  Position: #{block[:start_pos]}-#{block[:end_pos]}"
+      puts "  Tick count: #{block[:tick_count]}"
+      puts "  Nesting depth: #{block[:depth]}"
+      puts "  Contains blocks: #{block[:nested_blocks].join(', ')}" unless block[:nested_blocks].empty?
+
+      content_preview = block[:content][0..80].gsub(/\n/, ' ')
+      puts "  Content preview: #{content_preview}..."
+    end
+  end
+end
+
+# Example usage
+if __FILE__ == $0
+  example = <<~MARKDOWN
+    Perfect! I've successfully implemented the tool use formatting with collapsed sections as requested. Here's what I implemented:
+
+    **Key Features:**
+
+    1. **Tool Use Detection**: The code now detects `tool_use` entries in assistant message content arrays
+    2. **Tool Pairing**: When a `tool_use` is found, it looks for the immediately following `tool_result` and pairs them together
+    3. **Collapsed Sections**: Uses GitHub's `<details>/<summary>` tags from the cheatsheet
+    4. **Formatted Output**: Each tool use gets:
+       - A "## Tool Use" header
+       - A collapsed section with the tool name as the summary
+       - Input parameters displayed in a JSON code block
+       - A nested collapsed section for tool results (if present)
+
+    **Example Output:**
+    ```markdown
+    ## Tool Use
+    <details>
+    <summary>Read</summary>
+
+    ```json
+    {
+      "file_path": "/path/to/file.txt"
+    }
+    ```
+
+    <details>
+    <summary>Tool Result</summary>
+
+    ```
+    File contents here
+    ```
+    </details>
+    </details>
+    ```
+
+    **Test Coverage:**
+    - All 20 tests pass
+    - Tests verify tool use formatting with and without results
+    - Tests ensure text content is still extracted cleanly
+    - Tests confirm non-text content is preserved appropriately
+
+    The tool use sections are now cleanly formatted with collapsible sections that show the tool name prominently and hide the technical details until clicked. Ready to continue customizing the formatting further!
+  MARKDOWN
+
+  parser = MarkdownCodeBlockParser.new(example)
+  parser.parse
+  parser.display_analysis
+
+  puts "\n" + "="*50
+  puts "Escaped version:"
+  puts "="*50
+  puts parser.escape_nested_blocks
+end

data/lib/secret_detector.rb

@@ -0,0 +1,89 @@
+require 'json'
+require 'tempfile'
+
+class TruffleHogSecretDetector
+  class Finding
+    attr_reader :type, :pattern_name, :match, :detector_name, :verified, :line
+    
+    def initialize(detector_name, match, verified, line = nil)
+      @type = 'secret'
+      @pattern_name = detector_name
+      @detector_name = detector_name
+      @match = match
+      @verified = verified
+      @line = line
+    end
+    
+    # For backward compatibility with old SecretDetector interface
+    alias_method :confidence, :verified
+  end
+  
+  def initialize
+    # Check if trufflehog is available
+    unless system('which trufflehog > /dev/null 2>&1')
+      raise "TruffleHog not found. Install it with: brew install trufflehog"
+    end
+  end
+  
+  def scan(text)
+    return [] if text.nil? || text.empty?
+    
+    findings = []
+    
+    # Create a temporary file with the text
+    Tempfile.create(['trufflehog_scan', '.txt']) do |temp_file|
+      temp_file.write(text)
+      temp_file.flush
+      
+      # Run trufflehog on the temporary file
+      output = `trufflehog filesystem --json --no-verification #{temp_file.path} 2>/dev/null`
+      
+      # Parse each line of JSON output
+      output.each_line do |line|
+        line = line.strip
+        next if line.empty?
+        
+        begin
+          result = JSON.parse(line)
+          # Skip non-detection results (like log messages)
+          next unless result['DetectorName'] && result['Raw']
+          
+          findings << Finding.new(
+            result['DetectorName'],
+            result['Raw'],
+            result['Verified'] || false,
+            result.dig('SourceMetadata', 'Data', 'Filesystem', 'line')
+          )
+        rescue JSON::ParserError
+          # Skip malformed JSON lines
+          next
+        end
+      end
+    end
+    
+    findings
+  end
+  
+  def redact(text, replacement = '[REDACTED]')
+    return text if text.nil? || text.empty?
+    
+    findings = scan(text)
+    return text if findings.empty?
+    
+    redacted_text = text.dup
+    
+    # Sort findings by match length (longest first) to avoid partial replacements
+    findings.sort_by { |f| -f.match.length }.each do |finding|
+      redacted_text = redacted_text.gsub(finding.match, replacement)
+    end
+    
+    redacted_text
+  end
+  
+  def has_secrets?(text)
+    !scan(text).empty?
+  end
+end
+
+# Alias for backward compatibility
+SecretDetector = TruffleHogSecretDetector

data/lib/templates/default.html.erb

@@ -0,0 +1,241 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><%= title %></title>
+    <%= include_prism %>
+    <style>
+        :root {
+            --dark-brown: #592d1c;
+            --medium-brown: #cc7c5e;
+            --light-brown: #f3dfd8;
+            --lightest-brown: #f9efec;
+            --light-blue: #a6d2e3;
+            --dark-blue: #1c4859;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;
+            line-height: 1.6;
+            color: var(--dark-brown);
+            background-color: var(--lightest-brown);
+            margin: 0;
+            padding: 20px;
+        }
+
+        .conversation-content {
+            max-width: 900px;
+            margin: 0 auto;
+            background: white;
+            padding: 32px;
+            border-radius: 16px;
+            box-shadow: 0 4px 6px rgba(89, 45, 28, 0.1);
+        }
+
+        /* Headers */
+        h1 {
+            color: var(--dark-blue);
+            border-bottom: 2px solid var(--light-blue);
+            padding-bottom: 12px;
+            margin-bottom: 24px;
+            border-radius: 0 0 8px 8px;
+        }
+
+        h2 {
+            color: var(--dark-brown);
+            margin-top: 32px;
+            margin-bottom: 16px;
+            border-bottom: 1px solid var(--medium-brown);
+        }
+
+        /* Code blocks - integrate with Prism.js */
+        pre[class*="language-"], 
+        pre:not([class*="language-"]) {
+            background: var(--dark-blue) !important;
+            border-radius: 12px;
+            overflow-x: auto;
+            margin: 16px 0;
+            padding: 16px;
+        }
+
+        code[class*="language-"],
+        pre:not([class*="language-"]) > code {
+            color: var(--light-blue) !important;
+            text-shadow: none !important;
+            font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', monospace;
+        }
+
+        /* Inline code (no language class) */
+        :not(pre) > code:not([class*="language-"]) {
+            background: var(--light-brown);
+            color: var(--dark-brown);
+            padding: 2px 6px;
+            border-radius: 6px;
+            font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', monospace;
+        }
+
+        /* Override Prism.js colors for better contrast on dark background */
+        .token.comment,
+        .token.prolog,
+        .token.doctype,
+        .token.cdata { color: #a0a0a0 !important; }
+        
+        .token.punctuation { color: #f8f8f2 !important; }
+        
+        .token.property,
+        .token.tag,
+        .token.boolean,
+        .token.number,
+        .token.constant,
+        .token.symbol,
+        .token.deleted { color: #f92672 !important; }
+        
+        .token.selector,
+        .token.attr-name,
+        .token.string,
+        .token.char,
+        .token.builtin,
+        .token.inserted { color: #a6e22e !important; }
+        
+        .token.operator,
+        .token.entity,
+        .token.url { color: #f8f8f2 !important; }
+        
+        .token.atrule,
+        .token.attr-value,
+        .token.keyword { color: #66d9ef !important; }
+        
+        .token.function,
+        .token.class-name { color: #e6db74 !important; }
+        
+        .token.regex,
+        .token.important,
+        .token.variable { color: #fd971f !important; }
+
+        /* Blockquotes (thinking content) */
+        blockquote {
+            border-left: 4px solid var(--light-blue);
+            margin: 16px 0;
+            padding: 12px 20px;
+            background: var(--lightest-brown);
+            border-radius: 0 12px 12px 0;
+            font-style: italic;
+            color: var(--dark-blue);
+        }
+
+        /* Details/Summary (collapsible sections) */
+        details {
+            margin: 16px 0;
+            border: 1px solid var(--light-brown);
+            border-radius: 12px;
+            overflow: hidden;
+        }
+
+        summary {
+            background: var(--light-brown);
+            color: black;
+            padding: 12px 16px;
+            cursor: pointer;
+            font-weight: 600;
+            border-radius: 12px 12px 0 0;
+            transition: background-color 0.2s ease;
+        }
+
+        summary:hover {
+            background: var(--medium-brown);
+            color: white;
+        }
+
+        details[open] summary {
+            border-radius: 12px 12px 0 0;
+        }
+
+        details > *:not(summary) {
+            padding: 16px;
+            margin: 0;
+        }
+
+        details > pre {
+            margin: 0;
+            border-radius: 0;
+        }
+
+        /* Tables */
+        table {
+            border-collapse: collapse;
+            width: 100%;
+            margin: 16px 0;
+            border-radius: 12px;
+            overflow: hidden;
+            box-shadow: 0 2px 4px rgba(89, 45, 28, 0.1);
+        }
+
+        th, td {
+            padding: 12px 16px;
+            text-align: left;
+            border-bottom: 1px solid var(--light-brown);
+        }
+
+        th {
+            background: var(--medium-brown);
+            color: white;
+            font-weight: 600;
+        }
+
+        tr:nth-child(even) {
+            background: var(--lightest-brown);
+        }
+
+        /* Links */
+        a {
+            color: var(--dark-blue);
+            text-decoration: none;
+            border-bottom: 1px solid var(--light-blue);
+            transition: border-color 0.2s ease;
+        }
+
+        a:hover {
+            border-bottom-color: var(--dark-blue);
+        }
+
+        /* Horizontal rules */
+        hr {
+            border: none;
+            height: 2px;
+            background: linear-gradient(to right, var(--light-blue), var(--medium-brown), var(--light-blue));
+            margin: 32px 0;
+            border-radius: 2px;
+        }
+
+        /* Lists */
+        ul, ol {
+            padding-left: 24px;
+        }
+
+        li {
+            margin: 8px 0;
+        }
+
+        /* Strong/Bold text */
+        strong, b {
+            color: var(--dark-brown);
+            font-weight: 600;
+        }
+
+        p {
+            overflow: scroll;
+        }
+
+        /* Session metadata styling */
+        p strong {
+            color: var(--dark-blue);
+        }
+    </style>
+</head>
+<body>
+    <main class="conversation-content">
+        <%= content %>
+    </main>
+</body>
+</html>