l1 complete

Author: NSHkr

CLAUDE.md

@@ -23,7 +23,15 @@ JsonRemedy - A practical, multi-layered JSON repair library for Elixir that inte
 - ✅ Wrapper text extraction (HTML, prose)
 - ✅ Encoding normalization
 
-**Status**: **TDD COMPLETE** - All 14 tests passing, code quality checks pass
+**Implementation Status**: **TDD COMPLETE** 
+- ✅ Core functionality implemented (21/21 unit tests passing)
+- ✅ LayerBehaviour contract fully implemented
+- ✅ All required callbacks: `process/2`, `supports?/1`, `priority/0`, `name/0`, `validate_options/1`
+- ✅ Public API functions: `strip_comments/1`, `extract_json_content/1`, `normalize_encoding/1`
+- ✅ Context-aware processing that preserves string content
+- ✅ Performance tests passing (4/4 tests, all functions under performance thresholds)
+- ✅ Code quality checks passing (Credo, mix format)
+- ✅ Type specifications and documentation complete
 
 ### Phase 3: Layer 2 - Structural Repair 📋 PLANNED
 **Goal**: Fix missing/extra delimiters using state machine for context tracking
@@ -135,12 +143,17 @@ Example: `{message: "Don't change: True, None", active: True}`
 5. **Edge cases** (50% success rate): severely malformed (graceful failure OK)
 
 ## Next Steps
-1. ✅ **COMPLETED**: Layer 1 Content Cleaning with TDD (14/14 tests passing)
+1. ✅ **COMPLETED**: Layer 1 Content Cleaning with TDD 
+   - Core functionality (21/21 unit tests passing)
+   - LayerBehaviour contract implementation
+   - Public API functions matching contracts
+   - Performance optimization (4/4 performance tests passing)
+   - Code quality and documentation
 2. 🟡 **NEXT**: Begin Layer 2 Structural Repair with state machine approach
 3. Create test fixtures for comprehensive scenarios
 4. Build context-aware syntax normalization for Layer 3
-5. Add performance benchmarking
-6. Create comprehensive integration tests
+5. Add integration tests across layers
+6. Create comprehensive property-based tests
 
 ## Important Reminders
 - **Test-first approach**: Write failing tests before implementation

lib/json_remedy/layer1/content_cleaning.ex

@@ -11,24 +11,14 @@ defmodule JsonRemedy.Layer1.ContentCleaning do
   Uses regex-based processing as it's the right tool for these content cleaning tasks.
   """
 
-  @type repair_action :: %{
-          layer: atom(),
-          action: String.t(),
-          position: non_neg_integer() | nil,
-          original: String.t() | nil,
-          replacement: String.t() | nil
-        }
-
-  @type repair_context :: %{
-          repairs: [repair_action()],
-          options: keyword(),
-          metadata: map()
-        }
-
-  @type layer_result ::
-          {:ok, String.t(), repair_context()}
-          | {:continue, String.t(), repair_context()}
-          | {:error, String.t()}
+  @behaviour JsonRemedy.LayerBehaviour
+
+  alias JsonRemedy.LayerBehaviour
+
+  # Import types from LayerBehaviour
+  @type repair_action :: LayerBehaviour.repair_action()
+  @type repair_context :: LayerBehaviour.repair_context()
+  @type layer_result :: LayerBehaviour.layer_result()
 
   @doc """
   Process input string and apply Layer 1 content cleaning repairs.
@@ -44,8 +34,8 @@ defmodule JsonRemedy.Layer1.ContentCleaning do
       input
       |> remove_code_fences()
       |> remove_comments()
-      |> extract_json_content()
-      |> normalize_encoding()
+      |> extract_json_content_internal()
+      |> normalize_encoding_internal()
 
     updated_context = %{
       repairs: context.repairs ++ new_repairs,
@@ -118,9 +108,9 @@ defmodule JsonRemedy.Layer1.ContentCleaning do
   @doc """
   Extract JSON from wrapper text (HTML, prose, etc.).
   """
-  @spec extract_json_content(input :: {String.t(), [repair_action()]}) ::
+  @spec extract_json_content_internal(input :: {String.t(), [repair_action()]}) ::
           {String.t(), [repair_action()]}
-  def extract_json_content({input, existing_repairs}) do
+  def extract_json_content_internal({input, existing_repairs}) do
     # Try to extract JSON from HTML tags first
     {result, html_repairs} = extract_from_html_tags(input)
 
@@ -134,9 +124,9 @@ defmodule JsonRemedy.Layer1.ContentCleaning do
   @doc """
   Normalize text encoding to UTF-8.
   """
-  @spec normalize_encoding(input :: {String.t(), [repair_action()]}) ::
+  @spec normalize_encoding_internal(input :: {String.t(), [repair_action()]}) ::
           {String.t(), [repair_action()]}
-  def normalize_encoding({input, existing_repairs}) do
+  def normalize_encoding_internal({input, existing_repairs}) do
     if String.valid?(input) do
       {input, existing_repairs}
     else
@@ -156,6 +146,113 @@ defmodule JsonRemedy.Layer1.ContentCleaning do
     end
   end
 
+  # LayerBehaviour callback implementations
+
+  @doc """
+  Check if this layer can handle the given input.
+  Layer 1 can handle any text input that may contain JSON with wrapping content.
+  """
+  @spec supports?(input :: String.t()) :: boolean()
+  def supports?(input) when is_binary(input) do
+    # Layer 1 can attempt to process any string input
+    # It looks for code fences, comments, or wrapper content
+    # Use fast string pattern matching instead of expensive operations
+    String.contains?(input, "```") or
+      String.contains?(input, "//") or
+      String.contains?(input, "/*") or
+      String.contains?(input, "<pre>") or
+      String.contains?(input, "<code>") or
+      long_text_with_content?(input)
+  end
+
+  def supports?(_), do: false
+
+  @doc """
+  Return the priority order for this layer.
+  Layer 1 (Content Cleaning) should run first in the pipeline.
+  """
+  @spec priority() :: non_neg_integer()
+  def priority, do: 1
+
+  @doc """
+  Return a human-readable name for this layer.
+  """
+  @spec name() :: String.t()
+  def name, do: "Content Cleaning"
+
+  @doc """
+  Validate layer configuration and options.
+  Layer 1 accepts options for enabling/disabling specific cleaning features.
+  """
+  @spec validate_options(options :: keyword()) :: :ok | {:error, String.t()}
+  def validate_options(options) when is_list(options) do
+    valid_keys = [:remove_comments, :remove_code_fences, :extract_from_html, :normalize_encoding]
+
+    invalid_keys = Keyword.keys(options) -- valid_keys
+
+    if Enum.empty?(invalid_keys) do
+      # Validate option values
+      case validate_option_values(options) do
+        :ok -> :ok
+        error -> error
+      end
+    else
+      {:error, "Invalid options: #{inspect(invalid_keys)}. Valid options: #{inspect(valid_keys)}"}
+    end
+  end
+
+  def validate_options(_), do: {:error, "Options must be a keyword list"}
+
+  defp validate_option_values(options) do
+    boolean_options = [
+      :remove_comments,
+      :remove_code_fences,
+      :extract_from_html,
+      :normalize_encoding
+    ]
+
+    Enum.reduce_while(options, :ok, fn {key, value}, _acc ->
+      if key in boolean_options and not is_boolean(value) do
+        {:halt, {:error, "Option #{key} must be a boolean, got: #{inspect(value)}"}}
+      else
+        {:cont, :ok}
+      end
+    end)
+  end
+
+  # Public API functions that match the API contracts
+
+  @doc """
+  Strip comments while preserving comment-like content in strings.
+  Public API version that takes string input directly.
+  """
+  @spec strip_comments(input :: String.t()) :: {String.t(), [repair_action()]}
+  def strip_comments(input) when is_binary(input) do
+    remove_comments({input, []})
+  end
+
+  @doc """
+  Extract JSON from wrapper text (HTML, prose, etc.).
+  Public API version that takes string input directly.
+  """
+  @spec extract_json_content(input :: String.t()) :: {String.t(), [repair_action()]}
+  def extract_json_content(input) when is_binary(input) do
+    # Need to rename one of these functions to avoid conflicts
+    # For now, call the internal pipeline function directly
+    extract_json_content_internal({input, []})
+  end
+
+  @doc """
+  Normalize text encoding to UTF-8.
+  Public API version that takes string input directly.
+  """
+  @spec normalize_encoding(input :: String.t()) :: {String.t(), [repair_action()]}
+  def normalize_encoding(input) when is_binary(input) do
+    # Need to rename one of these functions to avoid conflicts
+    # For now, call the internal pipeline function directly
+    normalize_encoding_internal({input, []})
+  end
+
   # Private helper functions
 
   defp remove_line_comments(input) do
@@ -312,6 +409,12 @@ defmodule JsonRemedy.Layer1.ContentCleaning do
 
   # Helper functions for string detection
 
+  # Fast check for long text that likely contains JSON content
+  defp long_text_with_content?(input) do
+    byte_size(input) > 100 and
+      not (String.starts_with?(input, "{") or String.starts_with?(input, "["))
+  end
+
   defp inside_string?(input, target) when is_binary(target) do
     # Find the position of target in input
     case String.split(input, target, parts: 2) do

lib/json_remedy/layer_behaviour.ex

@@ -0,0 +1,118 @@
+defmodule JsonRemedy.LayerBehaviour do
+  @moduledoc """
+  Defines the contract that all repair layers must implement.
+
+  Each layer is responsible for one specific type of repair concern
+  and should be composable with other layers in the pipeline.
+  """
+
+  @type repair_action :: %{
+          layer: atom(),
+          action: String.t(),
+          position: non_neg_integer() | nil,
+          original: String.t() | nil,
+          replacement: String.t() | nil
+        }
+
+  @type repair_context :: %{
+          repairs: [repair_action()],
+          options: keyword(),
+          metadata: map()
+        }
+
+  @type layer_result ::
+          {:ok, String.t(), repair_context()}
+          | {:continue, String.t(), repair_context()}
+          | {:error, String.t()}
+
+  @type syntax_rule :: %{
+          name: String.t(),
+          pattern: Regex.t(),
+          replacement: String.t(),
+          condition: (String.t() -> boolean()) | nil
+        }
+
+  @doc """
+  Process input string and apply layer-specific repairs.
+
+  Returns:
+  - `{:ok, processed_input, updated_context}` - Layer completed successfully
+  - `{:continue, input, context}` - Layer doesn't apply, pass to next layer  
+  - `{:error, reason}` - Layer failed, stop pipeline
+  """
+  @callback process(input :: String.t(), context :: repair_context()) :: layer_result()
+
+  @doc """
+  Check if this layer can handle the given input.
+  Used for optimization and layer selection.
+  """
+  @callback supports?(input :: String.t()) :: boolean()
+
+  @doc """
+  Return the priority order for this layer (lower = earlier).
+  Used to determine layer execution order.
+  """
+  @callback priority() :: non_neg_integer()
+
+  @doc """
+  Return a human-readable name for this layer.
+  Used in logging and debugging.
+  """
+  @callback name() :: String.t()
+
+  @doc """
+  Validate layer configuration and options.
+  Called during pipeline setup.
+  """
+  @callback validate_options(options :: keyword()) :: :ok | {:error, String.t()}
+
+  @optional_callbacks validate_options: 1
+
+  @doc """
+  Check if a position in the input is inside a string literal.
+  Used to avoid applying repairs to string content.
+  """
+  @spec inside_string?(input :: String.t(), position :: non_neg_integer()) :: boolean()
+  def inside_string?(input, position) do
+    before = String.slice(input, 0, position)
+
+    # Count unescaped quotes before this position
+    quote_count =
+      before
+      # Remove escaped quotes
+      |> String.replace(~r/\\"/, "")
+      |> String.graphemes()
+      |> Enum.count(&(&1 == "\""))
+
+    # Odd number means we're inside a string
+    rem(quote_count, 2) != 0
+  end
+
+  @doc """
+  Apply a single syntax rule with context awareness.
+  """
+  @spec apply_rule(input :: String.t(), rule :: syntax_rule()) ::
+          {String.t(), [repair_action()]}
+  def apply_rule(input, rule) do
+    if rule.condition && !rule.condition.(input) do
+      {input, []}
+    else
+      # Apply the rule
+      result = Regex.replace(rule.pattern, input, rule.replacement)
+
+      if result != input do
+        repair = %{
+          layer: :generic,
+          action: "applied rule: #{rule.name}",
+          position: nil,
+          original: input,
+          replacement: result
+        }
+
+        {result, [repair]}
+      else
+        {input, []}
+      end
+    end
+  end
+end