CHANGELOG.md

Changelog

All notable changes to the CCL test data will be documented in this file.

[1.1.0] - 2026-05-01

Bug Fixes

• tests: Clarify unindented-line fixture and add parse variant (042cda3)

  Clarifies a misleading test fixture, adds a parse-validation variant to close a coverage gap, and refreshes CLAUDE.md to match recent feature work.

• tests: Rename misleading fixture text in (042cda3)

• release: Exclude docs commits from version bumps (112f9e2)

  Summary

  • The docs!: commit in #135 caused just release-check to report a 2.0.0 bump — the conventional parser's default allowed_tags includes docs, so a breaking-marker on a docs commit triggers major.
  • Explicitly set allowed_tags without docs so doc-only commits (including breaking ones) are ignored for version bumping.
  • exclude_commit_patterns only filters the changelog output; it does not affect version bumps.

  Verification With this change, semantic-release version --print against main's commit range reports 1.0.1 (from the fix(tests) commit in #140) instead of 2.0.0.

• tests: Align parse_indented expectations with ocaml canonical (#134) (ffeebb2)

  Fixes #134.

  Three parse_indented expectations in api_proposed_behavior.json contradicted OCaml canonical semantics and their own build_hierarchy siblings. Each corrected expectation was verified by running the input through the OCaml reference parser.

  Changes

  complex_mixed_list_scenarios — parse_indented corrected from 11 flat entries to 4 (indented block collected as multiline value on config). build_hierarchy unchanged. No variant tag: output is universal.

  mixed_indentation_levels → mixed_indentation_levels_error — moved to api_errors.json. OCaml parse-errors on this input; the Go mock silently drops no-= lines. Tagged variants: [reference_compliant]; added to mock's SkipTestsByName.

  unindented_multiline_becomes_continuation → unindented_line_does_not_continue_value — renamed and corrected. OCaml's greedy key parser absorbs the unindented line into the next key, producing a multi-line key "This continues the header\nkey". Tagged variants: [reference_compliant] + features: [multiline_keys]; stays in mock's SkipTestsByName.

Features

• tests: Define build_model for bare-list nested-objects fixtures (bdc8ec9)

  Adds build_model expectations to the five bare_list_nested_objects_* fixtures in api_list_access.json that #143 deferred. Each shape was captured by piping the input through Ccl.Model.fix in the OCaml reference (helper landed in CatConfLang/ccl_test_runner_ocaml#2) — not derived by hand from the projection rule.

  Fixtures updated: bare_list_nested_objects_basic, _single_item, _minimal, _deeply_nested, _mixed_with_strings. The 6th sibling, _round_trip, doesn't declare build_model in its functions list and is left alone.

  The canonical OCaml fix destructively merges repeated empty-key entries: per-element field grouping that build_hierarchy preserves as a list of objects collapses into a single inner map with lex-sorted keys. For _basic, build_hierarchy returns {"items":{"":[{"name":"first","value":"1"},{"name":"second","value":"2"}]}} while build_model returns {"items":{"":{"name":{"first":{},"second":{}},"value":{"1":{},"2":{}}}}}. The mixed-strings case confirms bare strings and nested-object fields land side-by-side in the same inner map — the model cannot distinguish "list element that was a bare string" from "key with no children". This is the lossy-merge tradeoff #142 highlights, now concretely encoded.

• tests: Cover behavior:toplevel_indent_strip/preserve tag pair (95f292c)

  Closes #138.

  Adds coverage for the toplevel_indent_strip / toplevel_indent_preserve behavior pair so both tags drop off the validate-tags unused-warning list (41 → 43 distinct tags collected from source_tests/).

• tests: Exercise toplevel_indent_strip/preserve behaviors (95f292c)

  Adds four fixtures in api_whitespace_behaviors.json — two canonical_format and two round_trip — declaring the implementation-choice behavior tags. Inputs use top-level indentation so the two branches diverge in their re-serialized output.

• schema: Register toplevel_indent_strip/preserve behavior pair (95f292c)

  Adds entries to schemas/source-format.json (both $defs/behaviorMetadata and x-behaviorMetadata) and schemas/generated-format.json so the tags validate and auto-conflict generation marks them mutually exclusive.

• tests: Add parse-validation variant of (042cda3)

• tests: Add build_model canonical model function (7d1b54a)

  Adds build_model as a peer to build_hierarchy, exposing the OCaml-canonical recursive Map<string, Model> model where string values become keys pointing to {} and duplicate keys merge. Also restores the type-codegen pipeline (silently broken since the ccl-test-lib consolidation) so go generate ./types/... now works end-to-end.

• tests: Add build_model canonical model function (7d1b54a)

  Defines build_model as a function that produces the recursive Map<string, Model> shape — the abstraction OCaml's fix actually builds. Wires it through the schema, mock, loader, generator dispatch, and stats. Adds 5 fixtures in api_core_ccl_model.json and cross-links 3 entries in api_core_ccl_hierarchy.json so implementations' two views are validated against the same inputs.

  build_hierarchy is not redefined as a projection of build_model (issue #142 open questions 1–4 are explicitly deferred). The two functions remain independent, with cross-linked tests as the consistency check.

  One mock parity boundary: TestDeepNestedObjectsBuildModel is skipped under the function:parse run-only filter — same boundary as the long-standing TestDeepNestedObjectsBuildHierarchy. The mock walks entries flat and doesn't recurse into block values; pre-existing behavior, documented in the BuildModel mock comment.

[1.0.0] - 2026-04-19

Bug Fixes

• tests: Build_hierarchy requires parse_indented (2ed3ab7)

  Summary

  Fixes the apparent contradiction reported in #114 between mixed_indentation_levels_build_hierarchy and the multiline_plain_*_error_parse error tests.

  build_hierarchy consumes entries produced by parse_indented, not parse. parse correctly rejects lines without = delimiters, while parse_indented handles the indentation-based nesting that build_hierarchy needs. Implementations that declared build_hierarchy support but not parse_indented were being handed build_hierarchy tests (like mixed_indentation_levels) that they could not satisfy.

  This PR encodes that dependency in the test generator:

  • Adds build_hierarchy to compositeFunctionMap → {parse_indented, build_hierarchy}
  • Updates load from {parse, build_hierarchy} → {parse_indented, build_hierarchy}
  • Regenerates generated_tests/ and go_tests/ so every build_hierarchy validation now lists parse_indented in its required functions

  Implementations that don't expose parse_indented will now correctly filter out build_hierarchy tests.

• tests: Correct metadata for algebraic and edge case tests (c63d1d7)

  Summary

  Fixes two test data correctness issues.

  • fix(generator): add compose_associative, identity_left, and identity_right to compositeFunctionMap. These validations require parse and compose, but their generated functions arrays incorrectly listed the composite validation names, causing implementations declaring compose support to filter out these tests. Matches the pattern established for round_trip in #61.

  • fix(tests): replace empty_keys with multiline on key_with_newline_before_equals and complex_multi_newline_whitespace. Both tests exercise multi-line key accumulation (key spans newlines before =) and produce non-empty keys, so the empty_keys tag was misleading.

Features

• tests: Add multiline key test coverage (a48968a)

  Summary

  Adds 6 new tests exercising multi-line key accumulation edge cases, tagged with the multiline_keys feature added in #121:

  • multiline_key_with_spaces — multi-word key across lines
  • multiline_key_three_lines — key continues across three lines
  • multiline_key_empty_value — multi-line key with no value
  • multiline_key_with_regular_entry — multi-line key adjacent to a normal entry
  • multiline_key_blank_lines_between — blank line between key lines
  • multiline_key_tabs_in_continuation — tab-indented continuation

  Also adds these tests to the --basic-only skip list so implementations that don't yet support multi-line keys keep passing CI.

• schema: Add multiline_keys feature and multiline_values behavior (5ab2d87)

  Summary

  Reworks multi-line tagging: adds multiline_keys feature and multiline_values behavior, and removes the generic multiline feature that was redundant with multiline_continuation.

  Feature vs behavior

  Per #120:

  • multiline_keys (feature) — keys spanning multiple lines (e.g., key\n= val). Capability tag for gap reporting; all implementations should eventually support it.
  • multiline_continuation (feature) — any test requiring indented continuation support (pre-existing).
  • multiline_values (behavior) — narrower filter for tests whose expected output encodes a contested edge-case decision: empty first line after =, blank line lookahead, or continuation preservation.

  Every multiline_values test is also multiline_continuation. The behavior tag is narrower — it only applies to tests whose expected output reflects a specific choice that another implementation could defensibly make differently.

  multiline_continuation vs multiline_values — why both?

  The names sound similar, so here's how they differ.

  multiline_continuation alone — plain continuation, no contested decision

    Second line
    Third line ``` Every impl that supports indented continuations agrees: `value = "First line\n Second line\n Third line"`. No filtering needed.
  
  ##### `multiline_continuation` + `multiline_values` — empty first line after `=`
  
  ``` key =
    line1
    line2 ``` This suite's expected value: `"\n line1\n line2"` (leading newline preserved because the line after `=` was empty). An impl that strips the leading empty line (→ `"line1\n line2"`) is also defensible. The `multiline_values` tag lets that impl filter this test out.
  
  ##### `multiline_continuation` + `multiline_values` — blank line within continuation
  
  ``` key =
    line1
  
  line2 ``` This suite: `"\n line1\n\n line2"` (blank line preserved, continuation not terminated). Another impl could terminate at the blank line and treat `line2` separately.
  
  #### Why remove `multiline`
  
  The previous `multiline` feature example in the docs was `description = Line 1\nLine 2` — but that isn't a real CCL construct. Without indentation, `Line 2` is either its own entry or a parse error. Every actual multi-line value in the suite already qualified as `multiline_continuation`, so `multiline` was a less-specific alias and got dropped.
  
  #### Changes
  
  - **Schema**: add `multiline_keys` to feature enum, add `multiline_values` to behavior enum (with `x-behaviorMetadata`), remove `multiline` from feature enum in both source + generated formats.
  - **Config (Go)**: add `FeatureMultilineKeys` and `BehaviorMultilineValues` constants; remove `FeatureMultiline`; include `FeatureMultilineContinuation` in `AllFeatures()`.
  - **Tests**: tag 18 existing tests with `multiline_values` behavior; retag tests from `multiline` to `multiline_continuation` across 7 source files (dropping the tag on tests that already had both).
  - **Docs**: update test-selection-guide feature/behavior tables.
  
  
  
  
  
  

Refactoring

• Reshape tab/indent taxonomy to ocaml-canonical semantics (4ed7255)

  Refactors the tab/indent flag taxonomy to OCaml-canonical semantics. Closes #122, addresses #129.

  Taxonomy changes

  Removed behaviors (non-OCaml alternatives):

  • tabs_as_content, tabs_as_whitespace, toplevel_indent_preserve
  • toplevel_indent_strip (reclassified as a feature)

  Retained behaviors (genuine implementation choice):

  • indent_spaces / indent_tabs — canonical_format output style

  New features (always-on OCaml rules that tests annotate):

  • tab_in_value_preserved
  • continuation_tab_to_space
  • toplevel_indent_strip

  Expected-value corrections (#122)

  • behavior_combo_tabs_and_crlf: tabs preserved inside values
  • tabs_as_whitespace_multiline / _mixed_indent: continuation tabs normalized to 2 spaces

  Implementation

  • internal/mock/ccl.go::Parse(): continuation-line leading tabs now normalize 1:1 to spaces, matching OCaml.
  • Schemas, Go config (config/, internal/config/), and docs updated to the new vocabulary.
  • Source fixtures: 11 deleted, 13 retagged, 3 expected-value fixes. Generated tests: 919 → 904.

  Breaking change Behavior names tabs_as_content, tabs_as_whitespace, toplevel_indent_strip, toplevel_indent_preserve are removed from the schema. Downstream fixtures tagged with these must migrate.

[0.8.0] - 2026-04-03

Bug Fixes

• tests: Preserve empty strings in list_with_whitespace_reference build_hierarchy (bf29adc)

  The build_hierarchy expected output for list_with_whitespace_reference incorrectly filtered out empty string values from the array. The parse test correctly expected all 4 entries (including 2 empty strings), but build_hierarchy only expected ["normal", "spaced"].

  There is no schema-defined behavior for empty string filtering — array_order_lexicographic only controls sorting, not filtering. The proposed_behavior variant (list_with_whitespace) also preserves empty strings. Single empty values are preserved elsewhere (e.g. empty_list).

  Changes:

  • build_hierarchy expect: ["normal", "spaced"] → ["", "", "normal", "spaced"]
  • Added empty_keys feature tag (test exercises empty value handling)
  • Regenerated flat and Go test files

  Closes #111 Closes #112

  Co-authored-by: Copilot 223556219+Copilot@users.noreply.github.com

Features

• schema: Add structured predicate field to filter tests (d86dc9f)

  Summary

  Add an optional predicate object to both source and generated format schemas, enabling filter tests to declare their filtering criteria explicitly. Implements the schema and test data changes from ccl-typescript#23.

  Changes

  Schema

  • Added predicate property ({field, op, value}) to generated-format.json and source-format.json

  Existing tests updated (9 tests)

  • All filter tests now include explicit "predicate": {"field":"key","op":"!=","value":"/"}
  • 3 in api_comments.json, 6 in api_whitespace_behaviors.json

  New test cases (5 tests)

  • api_filter_predicates.json: key equality, value not-empty, value equality, no matches, keeps-all

  Go pipeline

  • Types: added Predicate struct, propagated through TestCase, FlatTestCase, and generated types
  • Generator: extracts/propagates predicate; removed incorrect comments feature auto-tagging for filter
  • Loader: handles predicate in compact format loading
  • Test generator: real assertions for comment-exclusion predicates; TODO stubs for others

  Backwards compatibility When predicate is absent, test runners fall back to comment-exclusion behavior.

[0.7.1] - 2026-03-29

Bug Fixes

• tests: Update round_trip_empty_multiline to expect true (a9ae5e6)

  The round_trip_empty_multiline test expected false because the sickle printer previously added a trailing space after = for section keys, causing re-parse to differ. Now that the printer correctly omits the trailing space, parse(print(parse(x))) == parse(x) holds true.

  Co-authored-by: Copilot 223556219+Copilot@users.noreply.github.com

[0.7.0] - 2026-03-29

Bug Fixes

• release: Bump heading levels in commit body descriptions (bb23e3d)

• tests: Correct tabs_as_whitespace to only strip leading tabs (debbe95)

  Summary

  Fix test expectations for tabs_as_whitespace behavior. This behavior applies to indentation only, not to tab characters within value content.

  Changes

  • tabs_as_whitespace_in_value: expectations now preserve internal tabs ("value\twith\ttabs" instead of "value with tabs")
  • tabs_as_whitespace_round_trip: same fix for round_trip output
  • tabs_canonical_format_as_whitespace: verified correct (only has leading tab)
  • Flat + Go tests regenerated

  Before Input: key = \tvalue\twith\ttabs

  Expected: "value with tabs" (all tabs converted — wrong)

  After Expected: "value\twith\ttabs" (only leading tab stripped —

  correct)

  Closes #96

• tests: Add array_order_insertion behavior to list tests (48386ae)

  Summary

  Closes #92.

  • Added array_order_insertion to behaviors array of 10 source tests in api_proposed_behavior.json that have insertion-order list expectations but no array_order_* tag
  • Added BehaviorArrayOrderInsertion/BehaviorArrayOrderLexicographic constants and array_ordering conflict group to config.go

  Implementations using lexicographic ordering (e.g., OCaml's Map.Make(String)) declare array_order_lexicographic but could not skip these tests because they were untagged.

  Affected tests

  • indented_line_is_continuation
  • mixed_duplicate_single_keys
  • empty_list
  • list_with_numbers
  • list_with_booleans
  • list_with_whitespace
  • list_with_unicode
  • list_with_special_characters
  • list_multiline_values
  • complex_mixed_list_scenarios

Features

• build: Add changelog-entry skill for commit message formatting (21c0138)

• tests: Add multiline_continuation feature tag (bf2f182)

  Summary

  Add multiline_continuation feature to distinguish indentation-based continuation tests from basic multiline support. Tag 3 tests in api_proposed_behavior.json:

  • indented_line_is_continuation
  • mixed_indentation_levels
  • list_multiline_values

  This allows implementations that support basic multiline but not indentation-as-continuation to skip just these tests.

  Changes

  • schemas/source-format.json — added to features enum
  • schemas/generated-format.json — added to features enum
  • ccl-config-schema.json — added to config features
  • config/config.go — added FeatureMultilineContinuation constant
  • Source tests tagged, flat + Go tests regenerated

  Closes #94

• tests: Add path_traversal feature tag for multi-component args (4c7a013)

  Summary

  • Adds a new path_traversal feature to the schema and Go config for tests that use multi-component args arrays in typed access functions (get_string, get_int, get_bool, get_float, get_list)
  • Tags 20 existing tests across 7 source test files that use multi-component args
  • Adds 9 new path traversal tests covering get_int, get_float, get_bool, get_string, and mixed typed access at both 2-level and 4-level nesting depths

  This addresses category 3 from #91 — implementations that support typed access functions but only single-key lookups (not recursive hierarchy traversal) can now declare they don't support path_traversal and skip these tests.

[0.6.2] - 2026-03-01

Bug Fixes

• tests: Correct behavior tag on key_with_tabs_ocaml_reference (bcea90e)

  The reference_compliant variant strips tabs around the = delimiter, which is tabs_as_whitespace behavior, not tabs_as_content. Fixes #83.

[0.6.1] - 2026-02-28

Bug Fixes

• tests: Resolve issues (b691aa5)

  Summary

  Fixes three related issues with test generation and expectations.

  Changes

  • fix(generator): add canonical_format to its own compositeFunctionMap entry (#79) Tests with canonical_format validation now include canonical_format in their functions array, so implementations that support parse+print but not canonical_format will correctly skip these tests.

  • fix(schema): add filter to CRLF behavior affectedFunctions (#80) The crlf_preserve_literal and crlf_normalize_to_lf behaviors now list filter in their affectedFunctions. This ensures the filter sub-test inherits CRLF behavior tags and conflict metadata during flat test generation, so implementations with crlf_normalize_to_lf correctly skip CRLF-preserving filter tests.

  • fix(tests): remove trailing whitespace from print expectations (#81) 21 print test expectations had trailing whitespace on lines where a key has a continuation or empty value (e.g. config = \n instead of config =\n). This caused round_trip: true assertions to be self-contradictory since print(parse(input)) != input. Updated the mock Print function to omit trailing space when the value is empty or starts with a newline, and fixed all affected test expectations.

  Closes #79, closes #80, closes #81

• tests: Resolve test inconsistencies (338d2fd)

  Summary

  • #75: Update round_trip_property_complex print expectation to use no-leading-space format (= item1) for empty keys, consistent with the fix in 13fb778
  • #76: Fix behavior tag propagation for composite validations (round_trip, canonical_format, load) by resolving to component functions before filtering — tabs_as_whitespace_round_trip_round_trip now correctly has behaviors: ["tabs_as_whitespace"]
  • #77: Update CRLF build_hierarchy tests to include / comment keys (as arrays for duplicates), consistent with ocaml_stress_test_original behavior

  Closes #75, closes #76, closes #77

[0.6.0] - 2026-02-24

Bug Fixes

• tests: Use no-leading-space format for top-level empty keys in print (13fb778)

  The print expectations for top-level empty keys used = value (leading space), which would be re-parsed as a continuation line, making round_trip: true contradictory. Changed to = value (no leading space) to match the input format. Indented empty keys within continuation values are unaffected.

  Fixes #72

Features

• tests: Add delimiter_first_equals test cases (e219dd8)

  Add three tests showing first-equals delimiter behavior as counterparts to the existing delimiter_prefer_spaced tests. Same inputs produce different parse results under each behavior:

  • delimiter_first_url_with_query_params: URL splits at first bare =
  • delimiter_first_multiple_equals: a=b = c=d splits at first =
  • delimiter_first_empty_value: a=b = splits at first =

• tests: Add delimiter_prefer_spaced test cases (ac139eb)

  Add three new tests for the delimiter_prefer_spaced behavior:

  • delimiter_spaced_multiple_equals: a=b = c=d splits on =
  • delimiter_spaced_fallback_no_space: key=value falls back to bare =
  • delimiter_spaced_empty_value: a=b = with empty value after =

  Closes #73

• tests: Add edge case tests, delimiter behavior, and update dependencies (59c1d6d)

  Summary

  • Add comprehensive edge case tests for relative paths, double slashes, URLs with special characters, and deeply nested structures
  • Add delimiter_first_equals / delimiter_prefer_spaced behavior pair to schema and config, addressing how parsers handle = in keys (e.g., URLs with query params)
  • Fix test inputs for intermediate section header lines to include trailing spaces, matching expected parse values
  • Upgrade JSON Schema dialect from Draft-07 to Draft 2019-09 to support $defs keyword
  • Bump Go from 1.25.4 to 1.26.0
  • Update npm dependencies: @commitlint/* to ^20.4.2, @sourcemeta/jsonschema to ^14.13.3, @tylerbu/cli to ^0.9.0, unist-util-visit to ^5.1.0

  Relates to #73, #74

• tests: Add crlf + comments test coverage (d09d581)

  Summary

  Add test cases for CRLF line endings combined with /= comment syntax, addressing the gap identified in #68.

  New Tests

  | Test Name | Behavior | Description | |-----------|----------|-------------| | crlf_normalize_comment_only | crlf_normalize_to_lf | Single comment with CRLF ending; parse recognizes comment, filter removes it | | crlf_preserve_comment_only | crlf_preserve_literal | Single comment with CRLF; \r preserved in value, filter still removes it | | crlf_normalize_comments_and_values | crlf_normalize_to_lf | Mixed comments and key-value pairs with CRLF | | crlf_preserve_comments_and_values | crlf_preserve_literal | Mixed comments and key-value pairs with CRLF; \r preserved | | crlf_normalize_multiple_comments | crlf_normalize_to_lf | Three consecutive comments with CRLF | | crlf_preserve_multiple_comments | crlf_preserve_literal | Three consecutive comments with CRLF; \r preserved |

  These 6 source tests generate 14 flat test assertions covering parse, filter, and build_hierarchy functions.

  Closes #68

[0.5.0] - 2026-02-17

Features

• tests: Add randomized fuzz test generator for special characters (64112a2)

  Summary

  Closes #66

  • Add fuzz/ package with seeded randomized test generator producing source-format JSON test cases covering special character combinations in CCL keys and values
  • Add generate-fuzz CLI subcommand to ccl-test-runner with --seed, --count, --output, --validate flags
  • Update justfile with generate-fuzz recipe and extend generate-flat to process source_tests/fuzz/
  • Generate and commit 50 fuzz tests (seed 42) covering 5 categories: single char keys, combo keys, positional chars, special values, nested structures

• tests: Add test case for forward slashes in map keys (950d0d2)

  Summary

  Add test case verifying that forward slashes in map keys are parsed correctly.

  This addresses the issue discovered while testing repoverlay, where sickle fails to parse map keys containing forward slashes (tracked in tylerbutler/santa#71).

  Test Case

    config/settings.json = .vscode/settings.json
    src/template.env = .env ```
  
  Validates:
  - **parse**: flat entry extraction with forward slashes in nested keys
  - **build_hierarchy**: nested object construction with keys like `config/settings.json`
  - **get_string**: typed value access via path containing forward slashes
  
  Closes #62
  
  

• build: Replace git-cliff with python-semantic-release (8561c42)

  Switch changelog generation from git-cliff to Python Semantic Release for better squash merge commit parsing.

• build: Add python-semantic-release configuration (8561c42)

  Configure PSR with parse_squash_commits for extracting multiple conventional commits from squash merge bodies. Add custom Jinja2 templates for changelog and release notes with commit links.

[0.4.0] - 2026-01-21

Bug Fixes

• tests: Add composite function mapping and bare list nested object tests (ad83c0c)

  Addresses #59 and #60.

• tests: Composite function mapping (ad83c0c)

  Composite functions now correctly report their required underlying functions:

  • round_trip → ["parse", "print"]
  • load → ["parse", "build_hierarchy"]
  • canonical_format → ["parse", "print"]

  Also standardizes on "print" (instead of "pretty_print") across config, loader, and types to match the schema.

• tests: Bare list nested object tests (ad83c0c)

  Adds 6 new tests for bare list syntax with nested object items:

  • bare_list_nested_objects_basic
  • bare_list_nested_objects_single_item
  • bare_list_nested_objects_minimal
  • bare_list_nested_objects_deeply_nested
  • bare_list_nested_objects_mixed_with_strings
  • bare_list_nested_objects_round_trip

• schema: Allow nested objects in expect arrays (ad83c0c)

  Updates source-format.json to use anyOf instead of oneOf for array items in expect fields, enabling get_list tests to return lists of complex objects (not just strings or entries).

Features

• config: Enable split_commits for multi-entry changelog parsing (de06fc5)

  Configure git-cliff to parse multiple conventional commits from commit bodies:

  • Enable split_commits to process each line individually
  • Add preprocessor to strip markdown header prefixes (###)
  • Add unique filter to deduplicate identical messages in template

• config: Add single-source-of-truth for conventional commit types (e0b69ea)

  Add commit-types.json as the canonical source for commit type definitions, changelog groupings, and scope configurations. Includes CCL format version and Python generator script to produce cliff.toml and commitlint.config.cjs.

[0.3.1] - 2026-01-09

Bug Fixes

• generation: Sort behavior conflicts for deterministic output (15fa979)

  Summary

  Sorts the behavior conflicts array alphabetically when auto-generating conflicts from metadata, preventing non-deterministic ordering in generated JSON files.

  Changes

  • Add sort.Strings() to GetConflictingBehaviors() in generator/metadata.go
  • Add sorting to GetAllBehaviors() for consistency
  • Regenerate test files with deterministic conflict ordering

  Problem

  Go's map iteration order is non-deterministic, causing the conflicts.behaviors arrays in generated JSON to flip-flop between regenerations (e.g., ["list_coercion_disabled", "array_order_lexicographic"] vs ["array_order_lexicographic", "list_coercion_disabled"]).

[0.3.0] - 2026-01-05

Bug Fixes

• tests: Add missing crlf behavior tags to build_hierarchy tests (7e08787)

  Closes #52

  • Add build_hierarchy test to crlf_preserve_literal_basic test
  • Add new crlf_preserve_nested_structure test with both parse and build_hierarchy validations
  • Auto-conflict generation ensures all tests have proper conflicts field

  Test count increases from 399 to 402 with 3 new test assertions.

Features

• schema: Add behavior metadata for auto-conflict generation (5dd3fd8)

  Summary

  • Add behavior metadata system to source-format.json for automatic conflict generation
  • Embed behavior definitions (affectedFunctions, mutuallyExclusiveWith) as x-behaviorMetadata extension
  • Auto-generate behavior conflicts during flat format generation based on mutual exclusivity rules
  • Remove need for manual conflicts declarations in source tests (deprecated field)

  Changes

  Schema consolidation:

  • Merge behavior-metadata.json into source-format.json using JSON Schema x- extension convention
  • Add $defs for reusable type definitions (behaviorName, functionName, featureName, variantName)
  • Single source of truth for behavior definitions and schema validation

  Generator enhancements:

  • Add LoadBehaviorMetadata() to extract x-behaviorMetadata from source-format.json
  • Filter behaviors per-function using affectedFunctions mapping
  • Auto-generate conflicts from mutuallyExclusiveWith definitions
  • Add --validate, --auto-conflicts, and --schemas CLI flags

  Source test cleanup:

  • Remove all manual conflicts fields from source tests (now auto-generated)
  • Regenerate flat format tests with proper behavior propagation

[0.2.0] - 2026-01-04

Bug Fixes

• tests: Add reference_compliant variant to key_with_tabs_ocaml_reference (52f20ad)

  Add missing variants tag to properly identify this test as expecting OCaml reference implementation behavior. This resolves the conflict where two tests with the same behavior requirement had different expected outputs.

  Related: tylerbutler/tools-monorepo#532

• schema: Add continuation baseline behaviors to config schema (c0c9670)

  Summary

  • Adds toplevel_indent_strip and toplevel_indent_preserve behaviors to ccl-config-schema.json
  • These behaviors were already present in source-format.json and generated-format.json but missing from the user-facing config schema
  • Fixes consistency issue identified during documentation review

  Context

  The config schema is used by implementations to declare their test runner capabilities. Without these behavior options, implementations couldn't properly declare their continuation baseline behavior choice.

• cli: Improve behavior conflict detection and display (e68c1f6)

  Summary

  Fixes behavior conflict detection in the stats command to correctly identify mutually exclusive behavior pairs and improves display formatting.

  Changes

  • Fix cross-contamination bug: When tests have multiple behaviors (e.g., list_coercion_enabled + array_order_insertion), conflicts are now only attributed to behaviors that share the same prefix. Previously, all behaviors on a test were associated with all declared conflicts, creating false positive relationships.

  • Add haveSameBehaviorPrefix() helper: Detects whether two behaviors are of the same type based on naming convention (e.g., list_coercion_*, array_order_*, tabs_as_*).

  • Improve conflict display: Shows bidirectional pairs on single lines with color-coded names instead of listing each direction separately.

  • Add missing conflict declarations: Added bidirectional conflict declarations to test data for:

    • tabs_as_content ↔ tabs_as_whitespace
    • crlf_normalize_to_lf ↔ crlf_preserve_literal
    • list_coercion_enabled ↔ list_coercion_disabled

  Result

  The just stats output now correctly shows all 5 mutually exclusive behavior pairs without false positives.

• generation: Propagate conflicts field to generated flat format (381134d)

  Summary

  Fixes the conflicts field not being propagated from source tests to the generated flat format.

  Changes

  • Add convertConflicts() function in generator/generator.go to convert *types.ConflictSet to *generated.GeneratedFormatSimpleJsonTestsElemConflicts
  • Include Conflicts field in the struct initialization within convertToFlatFormat()

  Impact

  Implementations consuming the flat format can now use conflicts metadata for test filtering directly, without parsing the source format or duplicating conflict logic.

  Fixes #49

• tests: Remove incorrect proposed_behavior for nested parsing (35a194f)

  Summary

  Removes an incorrectly specified test that expected wrong parse behavior. The test was mistakenly placed in api_proposed_behavior.json with a variants tag, but this was not actually a spec ambiguity - it was simply wrong.

  Problem

  The deeply_nested_list test in api_proposed_behavior.json expected parse to flatten nested structure into 6 separate entries. This contradicts the CCL specification: parse should preserve nested indented content as part of the value string, with structural interpretation deferred to build_hierarchy.

  This was not a legitimate "variant" (spec ambiguity between OCaml reference and proposed behavior) - it was an incorrect test expectation.

  Changes

  • Removed deeply_nested_list from api_proposed_behavior.json (incorrect test)
  • Moved deeply_nested_list_reference from api_reference_compliant.json to api_core_ccl_hierarchy.json as the canonical deeply_nested_list test
  • Removed TestDeeplyNestedListParse from skip list since it now passes

  Closes #42, closes #43

• cli: Update view commands to use build-bin recipe (e35296c)

  The build-test-reader recipe was removed but view-test and view-tests commands still referenced it. Updated all four view commands to use the consolidated build-bin recipe instead.

Features

• schema: Add toplevel_indent_strip and toplevel_indent_preserve behavior pair (8703083)

  Summary

  Adds a new mutually exclusive behavior pair for top-level continuation baseline detection, addressing issue #46.

  New behaviors:

  • toplevel_indent_strip - Strip leading indent at top-level, using N=0 as continuation baseline (OCaml reference behavior)
  • toplevel_indent_preserve - Preserve first key's indentation as the continuation baseline

  Changes:

  • Schema: Added both behaviors to source-format.json and generated-format.json
  • Config: Added toplevel_indent conflict group and ToplevelIndent field to runner config
  • Tests: Tagged existing whitespace normalization tests with toplevel_indent_strip + reference_compliant, added corresponding toplevel_indent_preserve test variants
  • Justfile: Updated skip-tags to exclude toplevel_indent_preserve tests (mock uses strip behavior)

  The toplevel_indent_strip tests are marked reference_compliant since this behavior is required for OCaml compatibility.

  Closes #46

[0.1.0] - 2025-12-31

Bug Fixes

• tests: Correct tabs_to_spaces behavior to use single space (52813ae)

  The tabs_to_spaces behavior should convert each tab to a single space, not two spaces. Fixed expectations in 7 tests:

  • tabs_to_spaces_in_value
  • tabs_to_spaces_leading_tab
  • tabs_to_spaces_multiple_tabs
  • tabs_to_spaces_multiline
  • tabs_canonical_format_to_spaces
  • spacing_and_tabs_combined_loose_to_spaces
  • behavior_combo_tabs_and_crlf

• tests: Correct tabs_to_spaces behavior to use single space (67824fb)

  Summary

  • Fixed 7 tests that incorrectly expected tabs to be converted to two spaces instead of one
  • The tabs_to_spaces behavior should convert each tab character to a single space

  Tests Fixed

  • tabs_to_spaces_in_value
  • tabs_to_spaces_leading_tab
  • tabs_to_spaces_multiple_tabs
  • tabs_to_spaces_multiline
  • tabs_canonical_format_to_spaces
  • spacing_and_tabs_combined_loose_to_spaces
  • behavior_combo_tabs_and_crlf

  Test plan

  • just reset passes
  • just validate passes

• tests: Correct filter function expectations to remove comments (0075205)

  Summary

  • Fix filter test expectations in api_comments.json to correctly expect comments removed
  • Fix mock Filter implementation to actually filter out comment entries (key="/")

  Problem The filter function tests were incorrectly expecting the same output as parse, keeping comment entries in the result. The filter function's purpose is to remove comment entries from parsed CCL data.

  Changes

  • comment_extension: Now expects 4 entries (without the 2 comment entries)
  • comment_syntax_slash_equals: Now expects empty array (input was only a comment)
  • section_headers_with_comments: Now expects 4 entries (without the 2 comment entries)
  • Mock Filter function now filters out entries where key == "/"

  Test plan

  • just reset passes
  • just validate passes

• tests: Remove incorrect canonical_format tests from proposed_behavior (4c29c7b)

  Summary

  • Remove 8 incorrect canonical_format tests from api_proposed_behavior.json
  • The canonical_format function always produces model-level transformation output (reference compliant behavior), not structure-preserving output
  • The removed tests had incorrect expectations showing canonical_format behaving like print

  Details

  The canonical_format function transforms key = value into nested form: key = value =

  The removed tests incorrectly expected structure-preserving output like: key = value

  Removed tests

  • canonical_format_empty_values
  • canonical_format_tab_preservation
  • canonical_format_unicode
  • canonical_format_line_endings_proposed
  • crlf_normalize_to_lf_proposed
  • crlf_normalize_to_lf_indented_proposed
  • canonical_format_consistent_spacing
  • deterministic_output

  Test plan

  • just validate passes
  • just reset passes
  • Stats updated: 205 tests, 447 assertions (was 213/463)

Features

• schema: Rename tab/spacing behaviors for clarity (67ef97d)

  Summary

  • Rename tab parsing behaviors for clarity: tabs_preserve → tabs_as_content, tabs_to_spaces → tabs_as_whitespace
  • Remove obsolete strict_spacing and loose_spacing behaviors (no longer relevant)
  • Add new indent output behaviors: indent_spaces and indent_tabs
  • Update schemas, Go code, test files, and documentation

  Breaking Changes

  Behavior names have been updated. Implementations using the old names will need to update:

  | Old Name | New Name | |----------|----------| | tabs_preserve | tabs_as_content | | tabs_to_spaces | tabs_as_whitespace | | strict_spacing | removed | | loose_spacing | removed |

  New behaviors added:

  • indent_spaces - Use spaces for printed indentation (default)
  • indent_tabs - Use tabs for printed indentation

  Test plan

  • just validate passes
  • just generate completes successfully
  • CI tests pass

  Closes #38

• tests: Add comprehensive behavior tests (268e8bd)

  Summary

  Adds 26 new test cases to improve coverage of parse-time and access-time configurable behaviors:

  • CRLF handling (6 tests): normalize vs preserve, multiline values, nested structures, mixed line endings
  • Strict spacing (5 tests): validates rejection of non-standard formats like key=value, key =value
  • Boolean edge cases (7 tests): case sensitivity, numeric 1/0, whitespace handling, empty values, nested objects
  • Type mismatch errors (4 tests): get_int on bool, get_bool on int, get_float on bool
  • Behavior combinations (2 tests): tabs+crlf, loose+tabs+crlf triple combos

  Test plan

  • JSON validates successfully
  • just reset regenerates tests without errors
  • All new tests follow source format schema

• tests: Add bare list indentation tests (0dc4727)

  Summary

  • Add canonical_format tests for bare list indentation validation
  • Tests verify nested bare lists use correct 2-space indentation
  • Catches formatting bugs where printers output incorrect indentation (e.g., 3 spaces instead of 2)

  New Tests

  • nested_bare_list_indentation: Single-level nested bare list
  • deeply_nested_bare_list_indentation: Multi-level nesting (2, 4, 6 spaces)

  Changes

  • Added tests to source_tests/core/api_whitespace_behaviors.json
  • Regenerated Go test files
  • Minor README formatting updates

[0.0.1] - 2025-12-08

Bug Fixes

• tests: Add list_coercion_enabled behavior to proposed_behavior tests (7c11ffa)

  Summary

  • Add missing list_coercion_enabled behavior tag to 8 tests in api_proposed_behavior.json that use get_list and expect list coercion behavior

  Affected Tests

  • empty_list
  • list_with_numbers
  • list_with_booleans
  • list_with_whitespace
  • deeply_nested_list
  • list_with_unicode
  • list_with_special_characters
  • list_multiline_values

  Context Without this tag, implementations with list_coercion_disabled would incorrectly run these tests and fail.

  Fixes #12

• tests: Add conflict metadata for tabs_preserve behavior (4a95c2c)

  Summary

  • Add conflicts field to 4 tests with tabs_preserve behavior
  • Documents mutual exclusivity with tabs_to_spaces behavior

  This helps test runners understand which behaviors conflict and enables better test filtering.

• Filter behavior tags to only apply to relevant functions (a85830d)

  Behavior tags like boolean_strict/boolean_lenient now only appear on tests for functions where they actually affect behavior (e.g., get_bool), not on parse or build_hierarchy tests where the values are just stored as strings.

  This change was implemented in ccl-test-lib's generator, which now filters behaviors based on a function mapping before assigning them to generated flat tests.

• tests: Add list_coercion_enabled behavior to api_list_access tests (7dd4a7b)

  Fixes missing behavior declarations in api_list_access.json test suite that were causing false failures for reference-compliant implementations.

  Tests in api_list_access expected list_coercion_enabled behavior (duplicate keys create lists accessible via get_list()) but had empty behaviors arrays, making them indistinguishable from behavior-agnostic tests.

  • basic_list_from_duplicates
  • large_list
  • list_with_comments

  These tests use duplicate keys to create lists and expect get_list() to return the actual array values. However, without the list_coercion_enabled behavior declaration:

  1. Test runners cannot properly filter based on implementation capabilities 2. Reference-compliant implementations (using list_coercion_disabled) see spurious failures 3. Results misleadingly show failures instead of skipped tests

  list_coercion_disabled (reference-compliant):

  • build_hierarchy() creates arrays from duplicate keys: {"ports": ["80", "443"]}
  • get_list("ports") returns null (refuses to return the array)

  list_coercion_enabled (proposed behavior):

  • build_hierarchy() creates arrays from duplicate keys: {"servers": ["web1", "web2", "web3"]}
  • get_list("servers") returns ["web1", "web2", "web3"] (returns the actual array)

  Added explicit "behaviors": ["list_coercion_enabled"] to all three affected tests in source_tests/core/api_list_access.json.

  ✅ JSON schema validation passed ✅ Test regeneration completed successfully ✅ Statistics now show: behavior:list_coercion_enabled: 8 tests (up from 5) ✅ Generated tests include proper behavior declarations

  • ✅ api_reference_compliant properly declares ["list_coercion_disabled"]
  • ✅ api_proposed_behavior properly declares ["list_coercion_enabled"]
  • ✅ api_list_access now properly declares behavior requirements

  Reference-compliant implementations using list_coercion_disabled will now correctly skip these tests instead of seeing false failures.

• Test-reader updates (a600007)

• test-reader: Integrate ccl-test-lib for proper type handling (e699d65)

  Fixes test-reader tool which was broken due to type mismatches with ccl-test-lib package. The tool now properly loads and displays both source and generated test formats.

  Key changes:

  • Replace custom types with ccl-test-lib types (TestSuite, TestCase, Entry)
  • Update config structure: Functions → SupportedFunctions with CCLFunction types
  • Fix loader API: use NewTestLoader() + LoadTestFile() with proper LoadOptions
  • Handle ValidationSet struct access: test.Validations.Parse instead of indexing
  • Add type assertions for test.Expected interface{} to extract entries
  • Remove unavailable Description field from TestCase
  • Update TUI rendering to work with new type structure

  The test-reader now successfully:

  • Loads both source and flat test formats using ccl-test-lib
  • Displays test cases with proper formatting and metadata
  • Shows expected entries, variants, and features correctly
  • Supports both static CLI and TUI modes

• Resolve test generation issues in ccl-test-data (97754df)

  Fixed multiple issues that were preventing just generate from working:

  Generator fixes:

  • Handle both array and map formats for Expected field in parse validations
  • Support direct value returns from loader for typed access validations
  • Add variable usage in TODO validations to prevent unused variable warnings
  • Fix function argument formatting to always use []string slices for CCL functions

  Template improvements:

  • Updated generateFlatParseValidation to handle loader's array format
  • Added generateTypedAccessForDirectValue helper for direct value handling
  • Modified formatArgs to always generate []string format for CCL API compatibility

  Test organization:

  • Simplified directory structure from level-based to feature-based organization
  • Updated package naming to match new structure

  Results:

  • All 366 tests now generate and compile successfully
  • Test execution works (failures are now logic-related, not generation issues)
  • Clean just generate workflow restored

• Resolve mock ccl implementation test failures (9fe1c7a)

  • Configure CRLF behavior to normalize line endings (BehaviorCRLFNormalize)
  • Enhance Parse function with multiline content support for indented sections
  • Update test generation to skip conflicting behavior tags
  • Focus implementation on Level 1 parsing functionality
  • Improve test success rate from 72% to 90% (142/157 passing tests)

  Changes:

  • internal/mock/ccl.go: Enhanced multiline parsing and CRLF normalization
  • internal/config/runner_config.go: Updated behavior configuration and supported functions
  • justfile: Added behavior exclusions for consistent test generation
  • go_tests/: Updated generated test files with proper tag filtering

• build: Resolve compilation errors in type references (d7237b4)

  Remove invalid field references causing build failures:

  • Remove Canonical field access from ValidationSet (field doesn't exist)
  • Fix Conflicts field location (TestCase.Conflicts vs TestMetadata.Conflicts)
  • Remove invalid SourceFormat field from GenerateOptions

  Ensures compatibility with ccl-test-lib type definitions.

• generation: Standardize null arrays to empty arrays (70acbb2)

  Replaces null values with empty arrays in generated test files for consistent JSON schema compliance and improved type safety.

  • behaviors: null → behaviors: []
  • features: null → features: []
  • variants: null → variants: []

• generation: Resolve schema validation and flat format issues (3ed9013)

  • Add $schema field support to generated-format.json schema
  • Fix array field null values by ensuring proper initialization
  • Use JSON tags for validation name extraction instead of field names
  • Update generated test files with corrected format
  • Resolve type compatibility issues in ccl-test-lib generator

  All generated files now pass schema validation successfully.

• Resolve linting issues and code quality improvements (4d24efd)

  • Removed unused functions to fix unused linting warnings
  • Fixed unchecked type assertions with proper error handling
  • Resolved variable name conflicts in loop scopes
  • Updated octal literal syntax to modern Go format
  • Added documentation to empty conditional branches
  • All linting issues now resolved, code passes golangci-lint checks

• Resolve format mismatch between ccl-test-lib and ccl-test-data (2810ff9)

  • Removed duplicate type definitions from ccl-test-data
  • Fixed ccl-test-lib generator to use proper schema-compliant types
  • Regenerated all flat format files to match schema requirements
  • Updated flat files from old format (expected: [...]) to schema format (expected: {count: N, entries: [...]})
  • Test generation now works correctly with 317 tests generated

  The core architecture issue is resolved:

  • ccl-test-lib is the single source of truth for shared types
  • Schemas define the authoritative data format
  • ccl-test-data imports and uses ccl-test-lib components
  • All format mismatches and JSON unmarshaling errors are fixed

• Omit empty conflicts field from flat json files (ac6619f)

  Previously, flat JSON files contained empty conflicts objects {} even when no conflicts were defined. This was inefficient for test runners and inconsistent with the intended omit-when-empty behavior.

  Changes:

  • Fixed ccl-test-lib generator to only set conflicts when non-empty
  • Added omitempty tag to Conflicts field in types.go
  • Updated justfile with generate-flat command for easier regeneration
  • Regenerated all flat test files with proper conflicts field handling

  Generated files now properly omit the conflicts field when empty, resulting in cleaner JSON and better performance for test runners.

• Resolve go vet issues in generated test files (37acad5)

  Remove unused input variables from error handling tests and fix undefined variable reference in list access test.

• Eliminate remaining kebab-case function names in metadata (1292997)

  • Update related_functions arrays to use underscore naming (expand-dotted → expand_dotted, build-hierarchy → build_hierarchy, etc.)
  • Fix cross-reference values to use underscores (performance-test → performance_test, security-test → security_test, etc.)
  • Maintain test data values like "in-memory" which are legitimate content
  • Preserve URLs and external references with hyphens

  All JSON files now consistently use underscore naming for all CCL-related identifiers while preserving legitimate hyphenated content and external references.

• Complete underscore naming harmonization across test suite (98760af)

  • Update JSON schema patterns for all tag categories (function, feature, behavior, variant)
  • Harmonize all test JSON files to use underscore naming consistently
  • Update README documentation with corrected tag examples and function names
  • Correct generator code to handle underscore feature names
  • Update statistics collector for underscore feature mapping
  • Regenerate test files with harmonized naming scheme
  • Maintain backward compatibility through proper feature-to-category mapping

  This ensures complete schema consistency with underscore naming convention throughout the entire test suite ecosystem.

• Harmonize function tags to use underscores for schema consistency (c393b3a)

  • Update all function tags from hyphenated to underscore format: build-hierarchy → build_hierarchy
    • expand-dotted → expand_dotted
    • get-string/int/bool/float/list → get_string/int/bool/float/list
    • pretty-print → pretty_print
    • parse-value → parse_value
  • Add missing boolean and list coercion behavior tags to README
  • Correct function names: make-objects → build_hierarchy, compose → combine
  • Add parse_value function to documentation
  • Update generated test files to reflect tag changes

  All function tags now match schema validation names for seamless integration.

• Update json schema to match recent ccl api changes (e06d9e5)

  • Replace function:make-objects tags with function:build-hierarchy (follows Sept 2025 API rename)
  • Add function:load to schema patterns for integration tests
  • Add feature:experimental-dotted-keys to allowed feature patterns
  • Add new feature enum values: core-ccl-parsing, core-ccl-hierarchy, core-ccl-integration
  • Add optional llm_metadata field with comprehensive property definitions
  • Remove duplicate make-objects reference from llm_metadata.related_functions

  All 12 test files now validate successfully against updated schema.

• Enable boolean true/false tests in lenient mode (641a25a)

  Update parse_boolean_true and parse_boolean_false tests to include both behavior:boolean-strict and behavior:boolean-lenient tags, removing the conflicts array. These fundamental boolean values work identically in both modes - only extended values like "yes"/"no" differ between modes.

  This fixes a coverage gap where lenient mode implementations weren't testing basic "true"/"false" parsing, while maintaining proper conflicts for truly incompatible behavioral differences.

  Updated documentation to clarify the dual-mode support and guidance for test tagging with multiple behaviors when appropriate.

• Resolve json schema validation errors in test files (3024dfe)

  • Fix api-errors.json test 2: change count from 0 to 1 for whitespace_only_error_ocaml_reference
  • Fix api-typed-access.json test 15: change make_objects.expected from string to object for empty_value_reference_behavior

  All test files now pass schema validation.

• Resolve test data inconsistencies and validation issues (cf709b1)

  • Remove duplicate tests (composition_stability_ab, multiple_values_same_key_ports)
  • Fix conflicts arrays to use structured tags instead of test names
  • Add function:parse-value tag for parse_value validation tests
  • Add missing variant conflicts declarations for proper test isolation
  • Update schema to support parse-value function tag

  Addresses validation schema compliance and improves test organization.

• Resolve missing conflicts declarations for mutually exclusive tests (0d1b2cb)

  Fix critical bug where tests with contradictory expected outputs were both running for the same implementation behavioral choice, causing false failures.

  Changes:

  • Rename CRLF tests for clarity: crlf_normalization → crlf_normalize_to_lf, crlf_normalization_strict → crlf_preserve_literal
  • Update behavior tags: behavior:crlf-preserve/normalize → behavior:crlf-preserve-literal/crlf-normalize-to-lf
  • Add boolean parsing behavior tags: behavior:boolean-lenient vs boolean-strict
  • Rename boolean strict tests: *_strict → *_strict_literal for clarity
  • Add mutual conflicts declarations between all conflicting behaviors
  • Update schema to validate new behavior tag patterns
  • Update documentation and migration files with new tag system

  Fixes issue where implementations declaring behavior:crlf-preserve would run both CRLF tests with identical input but contradictory expected outputs, ensuring only one behavioral interpretation runs per implementation choice.

• Ensure deterministic test generation by sorting map keys (8d16742)

• Disallow count:0 in schema and fix assertion counting (0761989)

• Prevent unused imports in generated tests (e802eac)

  Fixed template logic to only include assert/require imports when tests have actual implemented validations, not just validation fields that generate TODO comments. This resolves linting errors for unused imports in generated test files.

• Allow error cases in typed access validation counted format (8cc481c)

  • Update schema to support mixed success/error cases in cases array
  • Enable flexible test organization while preserving assertion accuracy
  • Update documentation with counted format examples and test runner patterns

• Resolve npm audit vulnerabilities with fast-json-patch override (be799db)

• Consolidate level-4 typed parsing tests into unified schema (ca32581)

• Resolve all parser test failures and implement complete test suite (605527b)

  • Add comprehensive pretty printer test suite (15 tests) with round-trip, canonical format, and deterministic testing
  • Fix trailing newline handling in input parsing by cleaning split() artifacts
  • Implement targeted blank line preservation for empty multiline sections
  • Add detailed test failure reporting across all architecture levels
  • Update project documentation to reflect fully implemented pretty printer

  All 91 tests now pass across 4-level CCL architecture:

  • Level 1 (Entry Parsing): 48/48 ✓
  • Level 2 (Entry Processing): 11/11 ✓
  • Level 3 (Object Construction): 8/8 ✓
  • Level 4 (Typed Parsing): 8/8 ✓
  • Pretty Printer: 15/15 ✓
  • Error Handling: 1/1 ✓

• Correct parsing precedence - integers win overlapping cases (32b4588)

  • Change precedence from bool->int->float->string to int->float->bool->string
  • When both integer and boolean parsing enabled, integers take precedence over booleans for "0"/"1"
  • Booleans retain non-numeric forms: "true", "false", "yes", "no", "on", "off"
  • Update JSON test expectations: "1" → IntVal(1), "0" → IntVal(0)
  • Maintains 7/8 test success rate with correct logic

  Parsing logic: integers win overlap since booleans have many non-numeric alternatives

Features

• tests: Add indented line continuation test cases (9951c0c)

  Summary Add two new test cases for verifying indented line continuation behavior in CCL parsing.

  New Test Cases

  1. indented_line_is_continuation Verifies that indented lines after a key = value are treated as continuations of that value, not separate entries.

  Input: descriptions = First line second line descriptions = Another item

  Expected: descriptions should have 2 values: "First line\n second line" and "Another item"

  2. mixed_indentation_levels Tests interaction between indented continuations and unindented standalone keys.

  Input: key1 = value1 indented continuation key2 = value2 not indented key indented for not indented

  Expected behavior:

  • key1 value: "value1\n indented continuation"
  • key2 value: "value2" (no continuation since next line is unindented)
  • not indented key becomes a separate key with nested content

  Context These complement the existing unindented_multiline_becomes_continuation test which tests the

  inverse case (unindented lines becoming continuations). The new tests verify that indented lines correctly become continuations.

  Fixes #11

• tests: Unify tests to use inputs field (6ca9f71)

• tests: Add algebraic property functions and multi-input support (e0f7ceb)

  Add property verification functions to mock CCL implementation:

  • ComposeAssociative: verifies (a·b)·c == a·(b·c)
  • IdentityLeft: verifies compose(empty, x) == x
  • IdentityRight: verifies compose(x, empty) == x
  • RoundTrip: verifies parse(print(parse(x))) == parse(x)
  • Print: structure-preserving formatter for round-trip testing

  Update schemas to support:

  • Multiple inputs via 'inputs' array for algebraic tests
  • New validation functions in generated format
  • Boolean and text expected value types

  Refactor property tests to use dedicated verification functions instead of inline assertions, enabling proper algebraic property validation across the test suite.

• Add release workflow with git-cliff changelog generation (9757e01)

  • Add GitHub Actions workflow triggered by data-v*.*.* tags
  • Add git-cliff configuration for conventional commit changelog
  • Add release commands to justfile (release-check, release-preview, release)
  • Update $schema references to use relative paths for local validation
  • Add VS Code settings for JSON schema validation
  • Document release process in DEVELOPER_GUIDE.md

• Add array_order behaviors to schema and whitespace behavior tests (659bec7)

  Add missing array_order_insertion and array_order_lexicographic behaviors to ccl-config-schema.json (were already used in 36 tests but not defined).

  Add new api_whitespace_behaviors.json with 21 tests covering:

  • loose_spacing: 11 tests (previously 0 coverage)
  • tabs_to_spaces: 6 tests (previously 0 coverage)
  • Combined spacing + tab behavior tests

  Update CLAUDE.md to document the new behavior pair and test file.

• schema: Add array_order_insertion/lexicographic behavior group (c1197bd)

  Separate array ordering from reference_compliant variant into a proper behavior choice. This allows implementations to choose lexicographic sorting independently of other reference implementation behaviors.

  • Add array_order_insertion and array_order_lexicographic to schemas
  • Update test-selection-guide.md with new behavior group
  • Convert tests from reference_compliant variant to array_order behaviors
  • Rename *_reference tests to *_lexicographic where appropriate

• tests: Add reference_compliant test variants with proper conflicts (1ffff6e)

  Add reference-compliant variants for tests that differ between proposed and reference CCL behavior. Each variant now properly declares conflicts with the alternative interpretation.

  • Add _reference variant tests for complete_lists_workflow, bare_list_nested, bare_list_with_comments, bare_list_deeply_nested, and list_with_comments
  • Add list_coercion_disabled behavior to reference_compliant tests
  • Fix list ordering in reference_compliant tests (alphabetical)
  • Add conflicts declarations for mutually exclusive variants/behaviors

• tests: Add bare list auto-unwrapping tests for get_list (52abaf3)

  Summary

  Adds 6 new test cases to api_list_access.json that specify get_list should automatically unwrap bare lists (empty-key lists).

  Problem

  Previously, bare lists created with syntax like: ccl servers = = web1 = web2

  Would create hierarchy: {"servers": {"": ["web1", "web2"]}}

  And require awkward access via: get_list(config, "servers", "")

  Solution

  These tests specify that implementations should make get_list smart enough to automatically unwrap the empty-key structure:

  get_list(config, "servers") → ["web1", "web2"]

  This provides consistent API ergonomics for both list creation syntaxes:

  • Duplicate keys: servers = web1\nservers = web2
  • Bare lists: servers =\n = web1\n = web2

  Both now accessible via: get_list(config, "servers")

  New Test Cases

  1. bare_list_basic - Basic bare list unwrapping 2. bare_list_nested - Nested bare lists 3. bare_list_with_comments - Bare lists with comments 4. bare_list_deeply_nested - Deep nesting validation 5. bare_list_mixed_with_other_keys - Bare lists alongside regular keys 6. bare_list_error_not_a_list - Error handling for non-list paths

  Test Coverage Impact

  • Total tests: 186 (+6)
  • Total assertions: 393 (+18)
  • get_list tests: 54 (includes new bare list tests)
  • empty_keys feature tests: 48 (properly tagged)

  Implementation Guidance

  The get_list function should: 1. If path points to an array, return it (duplicate-key lists) 2. If path points to an object with only one key "" containing an array, unwrap and return it (bare lists) 3. Otherwise return null

  This makes the empty-key representation an implementation detail, not user-facing API.

• Rename parse_value to parse_dedented (4dce7ed)

  Summary

  Completes the rename of parse_value to parse_dedented across ccl-test-data repository, including schemas, source tests, documentation, implementation code, and all generated test files.

  Motivation

  The function parse_value was misleadingly named. It doesn't just "parse a value" - it performs indentation normalization (dedenting) by: 1. Calculating the common leading whitespace prefix across all lines 2. Stripping that prefix from all lines 3. Treating the dedented keys as top-level entries

  This is analogous to Python's textwrap.dedent() and is essential for build_hierarchy when recursively parsing nested CCL content.

  Changes

  Schemas & Documentation

  • ✅ schemas/source-format.json - Updated function enum
  • ✅ schemas/generated-format.json - Updated function enum
  • ✅ CLAUDE.md - Updated all references to parse_dedented
  • ✅ docs/*.md - Updated documentation

  Source Tests

  • ✅ All source_tests/core/*.json files - Updated function names in test definitions

  Implementation Code

  • ✅ internal/generator/templates.go - Updated ValidationSet references (2 locations)
  • ✅ internal/mock/ccl.go - Renamed ParseValue → ParseDedented method
  • ✅ internal/stats/collector.go - Updated function name references
  • ✅ internal/stats/enhanced.go - Updated statistics tracking

  Generated Files (Regenerated)

  • ✅ generated_tests/*.json - 327 tests regenerated with new function name
  • ✅ go_tests/parsing/*_test.go - All Go test files regenerated

• Refactor test generation with feature categorization and remove invalid associativity tests (7df4fe8)

  • Implement optional_ prefix for feature categorization in Go test generator
  • Remove duplicate tags from generated test files
  • Remove invalid associativity validation tests from algebraic property suite
  • Add comprehensive test runner design documentation
  • Fix CRLF normalization in api_reference_compliant test cases
  • Update Go version requirement to 1.25.1 in .mise.toml
  • Update schemas to reflect cleaner test structure

  Removes 12 invalid "associativity" validation tests that were incorrectly generated from source tests intended for parse validation only. Algebraic property tests now correctly contain only parse validations.

• Add typed_accessors feature for typed accessor function tests (36056a4)

  Add new "typed_accessors" feature to categorize tests that use typed accessor functions (get_int, get_float, get_bool). This enables implementations to skip typed accessor tests if they don't support type-aware value extraction.

  Changes:

  • Add "typed_accessors" feature to 18 test cases in api_typed_access.json
  • Update all three JSON schemas to include "typed_accessors" in valid features enum
  • Maintain backward compatibility with existing feature categorization system

  The feature follows the established pattern where features categorize test content by CCL syntax/functionality rather than implementation requirements.

• Refactor justfile with reusable test runner invocation (88f36dc)

  This commit refactors the test execution system to use a unified, reusable approach that ensures consistent behavior between different test commands.

  Changes:

  • Add --skip and --basic-only flags to test runner CLI
  • Create _run-tests helper function in justfile for reusable test invocation
  • Make 'just test' run passing tests by default (--basic-only mode)
  • Add 'just test --all' option to run all tests including failures
  • Update dev-basic to use new test runner instead of hardcoded gotestsum
  • Add convenience aliases: test-all and test-comprehensive

  The key improvement is that 'just test' now passes by default, while 'just test --all' provides access to comprehensive testing when needed. Both 'just reset' and 'just test' now have identical, predictable behavior.

• Add test exclusion to just reset for progressive implementation (26b1d47)

  Updates just reset (dev-basic) command to exclude 4 problematic edge case tests:

  • TestKeyWithNewlineBeforeEqualsParse: newline within key portion
  • TestComplexMultiNewlineWhitespaceParse: complex whitespace with newlines
  • TestDeeplyNestedListParse: nested structure parsing expectations
  • TestRoundTripWhitespaceNormalizationParse: whitespace handling inconsistencies

  This demonstrates how test runners can implement progressive CCL support by excluding specific failing tests while maintaining clean CI for core functionality. Results: 153 tests pass, 209 skipped, 0 failed.

• Remove level-related infrastructure from stats and cli systems (64406b4)

  • Remove LevelBreakdown field and processing from enhanced stats
  • Remove level field from SourceTest struct
  • Remove --levels CLI flag and related filtering logic
  • Update justfile to remove level-specific commands
  • Update buildPackagePatterns to work without level filtering
  • Maintain backward compatibility for all other functionality

• Remove level property from json schemas and test data (c8cce07)

  Phase 1 of level removal - eliminate level concept from test data structure

  Changes:

  • Remove level property from source-format.json and generated-format.json schemas
  • Remove level fields from all source test JSON files (12 files)
  • Maintain JSON structure integrity and schema validation
  • All tests continue to validate successfully

  Breaking change: level field no longer supported in test format

• Restructure source tests to support $schema fields (c299e89)

  • Convert all source test files from array to object format with $schema field
  • Update schema to support top-level object with tests array
  • Remove backward compatibility code from stats collectors
  • All 12 source test files now include JSON Schema validation
  • Consolidated schema files and cleaned up temporary artifacts

• Add simplified yaml configuration system for ccl test runner (ade05c2)

  • Ultra-simple config format with arrays of strings only
  • JSON Schema validation via jv tool
  • Go validation with conflict detection for mutually exclusive behaviors
  • CLI validation tool at cmd/validate-config/
  • Exact naming matching test tag values (boolean_lenient, crlf_normalize_to_lf, etc.)
  • Minimal requirements: only functions array is required
  • Replaces complex 286-line Go config with ~10 lines of YAML

  Example ccl-config.yaml: ```yaml functions: [parse, build_hierarchy, get_string]

  behaviors: [boolean_lenient, crlf_normalize_to_lf]

  variants: [proposed_behavior] ```

• Add claude code workflows (d849cde)

• schema: Update json format to object-based structure with proper $schema usage (c4427dd)

  • Change from array-based to object-based format with $schema at top level
  • Remove repeated $schema fields from individual test items
  • Use $ref definitions for proper type generation with go-jsonschema
  • Update all generated test files to new format structure
  • Maintain full type safety and validation while following JSON Schema standards

  Format changes:

  • Before: [{"$schema": "...", "name": "..."}, ...]
  • After: {"$schema": "...", "tests": [{"name": "..."}, ...]}

• schema: Implement conditional args field requirements (074fc30)

  • Add conditional args requirements in JSON schema using if/then/else logic
  • Args field now required only for typed access functions (get_string, get_int, get_bool, get_float, get_list)
  • Updated schema description to clarify args field usage semantics
  • Regenerated flat tests and Go tests with refined args field behavior
  • Tests now show args field only where semantically required, cleaner JSON for other validation types

  This complements the ccl-test-lib fixes for args field generation logic.

• schema: Standardize on canonical_format function name (d46d282)

  Remove naming inconsistency between pretty_print and canonical_format by standardizing on canonical_format as the official function name.

  Changes:

  • Remove pretty_print from schema enums in favor of canonical_format
  • Update README.md documentation to use canonical_format
  • Clarify that Go PrettyPrint method implements canonical_format
  • Update function level from 5 to 4 to match actual implementation
  • All existing tests continue to work without breaking changes

  This resolves the confusion where schemas allowed both names but only canonical_format was actually implemented and tested.

• config: Centralize behavioral choices with validation (af8c4d1)

  • Implement centralized RunnerConfig with explicit behavioral choice validation
  • Add strict validation requiring explicit choices for mutually exclusive behaviors
  • Update test generation to use configuration-based filtering with conflict detection
  • Regenerate test files with updated configuration system

  Configuration system validates:

  • CRLF handling: normalize vs preserve
  • Tab handling: preserve vs convert to spaces
  • Spacing: strict vs loose
  • Boolean parsing: strict vs lenient
  • List coercion: enabled vs disabled
  • Specification variant: proposed vs reference compliant

  Test generation now filters incompatible tests based on behavioral choices.

• config: Centralize behavioral choices with validation (914d719)

  Implement centralized configuration system that requires explicit choices for all mutually exclusive behavioral options and validates them at runtime.

  • Add RunnerConfig with required behavioral choice validation
  • Implement conflict detection for incompatible test tags
  • Update test runner CLI with configuration validation
  • Add custom filtering for tag-based test selection
  • Ensure all behavioral choices are explicitly made

  Addresses scattered configuration issue by centralizing all variant, feature, and behavior choices in a single validated configuration system.

• Fix ccl test suite failures and enhance architecture (26c501d)

  • Fix flat generator metadata preservation for behavior-based filtering
  • Update schemas with hybrid approach (optional source, required generated)
  • Clean test data by removing empty metadata fields from all source files
  • Restore stats tool functionality for source format files
  • Rewrite implementation guide to match flat format architecture
  • Update ccl-test-lib types for proper JSON marshaling

  Resolves test generation pipeline issues where behavior/variant/feature metadata was lost during source-to-flat conversion, causing filtering failures. All 180 tests now properly preserve metadata for accurate test selection and execution.

• Replace schemas with current format validation (d07dcbc)

  Update test validation schemas to match actual file formats:

  • Replace source-format.json with schema for current source_tests/ structure

    • Direct array format (not wrapped objects)
    • Simple tests array with function/expect pairs
    • Support for all CCL functions and flexible return types
    • Optional features, behaviors, variants, level fields

  • Replace generated-format.json with schema for current flat test format

    • Enhanced validation for entries with required key/value fields
    • Complete function coverage including canonical_format, round_trip
    • Proper uniqueItems constraints on array fields

  • Update justfile validation commands to use renamed schemas

  • Remove experimental_dotted_keys from features (keep dotted_keys removed)

  All 12 source files and 177 flat files now validate successfully. Completes dual-format schema validation for CCL test suite.

• Implement separate fields schema for test metadata (ce79ffc)

  Replace unified tags array with typed fields for better API ergonomics:

  Schema Changes:

  • Add separate functions[], behaviors[], variants[], features[] fields
  • Replace string conflicts with categorized ConflictsByCategory structure
  • Add comprehensive enum validation for all field values
  • Maintain backward compatibility with structured tag parsing

  Generator Updates:

  • Parse structured tags (function:*, behavior:*, etc.) into separate arrays
  • Auto-generate function tags based on validation being tested
  • Organize conflicts by category (functions, behaviors, variants, features)
  • Preserve all original metadata while improving API usability

  Benefits:

  • Type safety: Enum validation prevents invalid values
  • Query ergonomics: .behaviors.includes('boolean_strict') vs string parsing
  • Self-documenting: All possible values clearly enumerated in schema
  • Better filtering: Direct field access for test selection

  Validation:

  • All 366 generated tests pass schema validation
  • Filtering works: 27 boolean_strict, 47 reference_compliant, 49 get_bool tests
  • Maintains rich metadata from original test structure

• Clarify crlf behavioral variants and consolidate dotted key features (bd35640)

  • Enhanced CRLF tests with intermediate parse validation to show behavioral differences
    • Reference: preserves CRLF during parsing, normalizes for output
    • Proposed: normalizes CRLF immediately during parsing
  • Renamed crlf_normalize_to_lf_reference → crlf_normalize_to_lf_indented_proposed
  • Removed underrepresented feature:dotted_keys tag (only 1 test)
  • Updated schema validation patterns to match actual feature usage
  • Added function:parse tags for completeness where missing

• Implement comprehensive llm optimization with enhanced metadata v2.1 (accba8b)

  Transforms CCL test suite into maximally LLM-consumable format while maintaining human usability.

  • Enhanced metadata schema v2.1 with llm_metadata blocks across all 8 JSON test files
  • Created tiered LLM documentation (llms.txt, llms-small.txt, llms-full.txt)
  • Implemented Go validation script for enhanced metadata compliance
  • Added cross-references to Gleam implementation and documentation site
  • Established progressive implementation levels (Level 1-4) with clear learning paths
  • Achieved 30-50% token reduction through structured content optimization
  • Built automated validation workflows with just commands
  • Created comprehensive documentation matrix and architectural guides

  Total: 452 test assertions across 167 tests now optimized for AI consumption with 100% metadata compliance.

• Add performance benchmarking with object pooling and enhanced error reporting (3b05ce4)

  • Add benchmark command with execution time and memory usage tracking
  • Implement object pooling in generator and stats packages to reduce allocations
  • Enhance mock CCL error messages with detailed debugging context and available keys
  • Add comprehensive package documentation for generator, stats, and mock packages
  • Include historical performance comparison and regression detection
  • Add benchmark recipes to justfile for development workflow

  🔨 Generated with Claude Code

• Add scrollable entry panes for improved large entry list handling (6cae224)

  • Add configurable entry display limit (6 entries max per view)
  • Implement CLI truncation with clear guidance to TUI mode for more entries
  • Add TUI entry scrolling with h/l (or ←/→) arrow key controls
  • Show scroll indicators with directional hints and remaining counts
  • Reset entry scroll position when navigating between tests
  • Add entry totals display and smart bounds checking
  • Update help text to include new entry scrolling controls

  Improves usability for tests with many parsed entries by preventing overwhelming displays while maintaining full access to all data.

• Enhance test-reader ui with improved entry display and navigation (cc9f5e6)

  • Add whitespace visualization with dots for spaces and arrows for tabs
  • Implement compact key/value entry layout with color-coded elements
  • Remove excessive boxing and metadata to focus on essential information
  • Add escape key navigation to return from file viewer to directory selection
  • Tighten spacing between entries for better information density
  • Brighten empty key/value indicators for improved visibility
  • Make TUI the default interactive mode instead of static CLI output

• Add directory support with file selection to test-reader cli (a034466)

  • Add directory input support for test-reader CLI
  • Implement interactive file selection in both CLI and TUI modes
  • Display file metadata including descriptions and test counts
  • Show parse test counts vs total test counts for each file
  • Add file browser TUI with navigation and selection
  • Maintain backward compatibility with single file input
  • Sort files alphabetically with enhanced styling
  • Include quit functionality and error handling

• Add test-reader cli with enhanced styling and tui support (b904f43)

  • Add test-reader CLI with lipgloss styling for beautiful output
  • Support both static styled output and interactive TUI mode
  • Color-coded boxes for different content types:
    • Cyan borders for headers and primary content
    • Green borders for successful parse validations
    • Red borders for error cases and conflicts
    • Yellow borders for metadata and warnings
  • Interactive TUI navigation with j/k keys, toggle modes
  • Add bubbletea dependency for TUI functionality
  • Add comprehensive just tasks for easy CLI usage:
    • just reader (alias for read-essential)
    • just tui (interactive mode)
    • just read-errors, read-objects, etc.
    • just read for custom files

  Usage: ./test-reader <file.json> [--tui]

• Implement feature-based tagging system with enhanced statistics (f404c3d)

  Replace descriptive tags with structured function/feature/behavior/variant tags to enable precise test selection for partial CCL implementations.

  Schema changes:

  • Add conflicts field to test metadata for mutual exclusivity
  • Define structured tag categories: function:, feature:, behavior:, variant:
  • Update level enum to include level 5 for formatting functions

  Enhanced statistics:

  • Track function requirements (function:parse, function:make-objects, etc.)
  • Monitor language features (feature:comments, feature:dotted-keys, etc.)
  • Analyze behavioral choices (behavior:crlf-preserve vs behavior:crlf-normalize)
  • Report implementation variants (variant:proposed-behavior vs variant:reference-compliant)
  • Count mutually exclusive tests and display conflict relationships

  Migration tools:

  • scripts/migrate-tags.py: Convert old tags to new structured format
  • scripts/clean-legacy-tags.py: Remove legacy descriptive tags
  • docs/tag-migration.json: Complete mapping between old and new tags
  • docs/schema-update.md: Implementation guide and usage examples

  Benefits:

  • Precise test filtering by implementation capabilities
  • Automatic conflict resolution for mutually exclusive behaviors
  • Progressive implementation support (minimal → full feature set)
  • Language-agnostic integration via JSON metadata

  Test suite now supports 167 tests with 21 mutually exclusive tests across 11 CCL functions, 6 language features, 3 behavioral choices, and 2 variants.

• Improve json schema validation constraints (dacc925)

  • Add count field to compose_validation and pretty_print_validation for consistent assertion tracking
  • Standardize count minimum values to 1 across all validations
  • Add tag pattern validation allowing both snake_case and kebab-case formats
  • Add input field minLength constraints for better validation
  • Fix error validation structure consistency by adding error handling to filter_validation, expand_dotted_validation, and make_objects_validation

• Expand reset baseline and fix crlf handling (7cc48e1)

  • Add line-endings tag to reset filter (15 → 29 active tests)
  • Fix test generator CRLF preservation in quoted strings
  • Update mock implementation to preserve \r characters in parsing
  • All tests pass with expanded baseline coverage

• Expand reset command to include more passing tests (2d7a56e)

  • Add redundant, quotes, and realistic tags to generate-level1
  • Increases active tests from 15 to 28 while maintaining all passing
  • Includes Level 2-4 basic functionality in baseline test set

• Add reset alias and fix test-mock workflow (d2f6451)

  • Add 'reset' alias for dev-basic command for easy repository state management
  • Fix test-mock to properly generate tests before running them
  • Fix dev-basic to use test-level1 instead of test-mock-basic
  • Update README with repository state management documentation
  • Clarify that clean passing state is required for commits and CI

• Replace find/xargs with cross-platform jv json schema validator (972544a)

  • Add jv CLI tool dependency for JSON schema validation
  • Update validate-schema tool to accept directories and find JSON files
  • Replace Unix-specific find/xargs commands with cross-platform jv
  • Update justfile to use jv directly for validation
  • Add tools.go for tool dependency management
  • Update deps command to install Go tools alongside modules

• Move package.json to scripts/ folder for cleaner project structure (80750ab)

  • Move package.json and package-lock.json to scripts/ folder
  • Update justfile docs commands to run from scripts/ directory
  • Update clean-all to target scripts/node_modules
  • Fix docs-check to run git diff from project root
  • Keep Node.js dependencies isolated to scripts where they're used
  • Project root now free of npm artifacts

• Replace rimraf with go-based clean utility (eb59f24)

  • Add cmd/clean/main.go - cross-platform recursive file deletion utility
  • Update justfile clean commands to use Go clean utility instead of npx rimraf
  • Remove rimraf from package.json devDependencies
  • Eliminate last npm-only dependency, keeping only Node.js deps for docs scripts

• Complete migration from package.json scripts to justfile (528f350)

  • Remove all scripts from package.json, keep only Node.js dependencies
  • Add rimraf for cross-platform file deletion
  • Enhance justfile with comprehensive commands:
    • docs-update, docs-check, docs-schema (replaces npm scripts)
    • unified deps command (deps-node + go mod tidy) test now includes validation + docs check (replaces npm test) test-generated for Go tests only ci command for full pipeline
  • All commands now use justfile as single interface

• Enhance justfile with mock development workflow and update readme (cece41a)

  • Add aliases (gen, t, l, v) for common commands
  • Add mock implementation development commands (generate-mock, test-mock, dev-mock)
  • Add level-specific test generation and execution commands
  • Add utility commands (stats, validate, dev-basic)
  • Update README to reflect current state with counted format requirement
  • Document Go test runner features and mock implementation
  • Add current test statistics (161 tests, 446 assertions)
  • Remove outdated legacy format documentation

• Enforce counted format with required count field in all validations (65213f8)

  • Update JSON schema to require count field in parse, filter, expand_dotted, make_objects, and typed access validations
  • Remove legacy simple formats, keeping only counted format structure
  • Convert all 8 test files to use counted format with appropriate count values
  • Update schema documentation with comprehensive count field explanation and examples
  • Add Go-based schema validation tool for future validation

• Add ocaml reference tests for array ordering differences (6f38f57)

  • Empty key array tests now have reference_compliant versions
  • Proposed versions maintain insertion order for arrays
  • OCaml reference sorts arrays alphabetically
  • Enables discussion of array ordering semantics and predictability

• Add ocaml reference tests for comprehensive parsing differences (4a13b7b)

  • Complex parsing tests now have reference_compliant versions
  • Shows OCaml reference parses nested structures differently
  • Tab normalization and stress test parsing variations captured
  • Preserves both flat and hierarchical parsing approaches for comparison

• Add ocaml reference tests for tab handling differences (7111482)

  • Tab preservation tests now have reference_compliant versions
  • Proposed versions preserve literal tabs in parsing output
  • OCaml reference normalizes tabs to single spaces during parsing
  • Maintains both interpretations for whitespace handling discussions

• Add ocaml reference tests for boolean parsing differences (4f03763)

  • Boolean tests now have reference_compliant versions showing OCaml strict parsing
  • OCaml reference only accepts "true"/"false", rejects "yes"/"no"/"on"/"off"/numeric
  • Proposed versions accept flexible boolean formats for user convenience
  • Enables productive discussion with OCaml maintainers about parsing standards

• Add ocaml reference test for boolean parsing differences (b023c14)

  • parse_boolean_yes: proposed parses 'yes' as true, OCaml reference errors
  • Demonstrates boolean parsing compatibility differences between implementations
  • Both behaviors preserved for maintainer discussions

• Add ocaml reference tests for parsing edge cases (b6bdbd9)

  • no_equals_continuation: proposed allows continuation, OCaml reference errors
  • crlf_normalization: proposed normalizes CRLF, OCaml reference preserves \r
  • Both behaviors preserved to enable discussion with reference maintainers

• Add proposed/reference compliance tagging for ocaml behavioral differences (a5a4058)

  • Add "proposed" tag to whitespace_only_error test representing current behavior
  • Add whitespace_only_error_ocaml_reference test showing OCaml reference behavior
  • Preserve both interpretations to enable discussion with reference maintainers

• Add optional assertion counting to test suite (b4163d2)

  • Add union types to schema supporting both legacy and counted formats
  • Support explicit assertion counts via count field in validations
  • Use consistent naming: items/result/cases for different validation types
  • Update collection scripts to report total assertions (241 across 148 tests)
  • Add documentation and examples for new counting format
  • Maintain 100% backwards compatibility with existing tests

• Implement validation-based test format with remark readme updater (15ccc37)

  • Transform all test files to validation-based format eliminating multi-level confusion
  • Replace fragile regex-based README updater with robust AST-based remark processor
  • Update schema to explicit API function validations (parse, filter, compose, make_objects, etc.)
  • Fix package.json scripts to exclude schema.json from validation
  • Add comprehensive documentation and example test runners
  • Remove deprecated schema files and old script

• Implement feature-based test organization with comprehensive schema documentation (94cca49)

  • Update JSON schema with standardized feature enum (parsing, processing, comments, object-construction, dotted-keys, typed-parsing, pretty-printing, error-handling)
  • Add feature metadata to all 135 test cases across 9 test files
  • Reorganize README from file-based to feature-based grouping (Core Parsing, Advanced Processing, Object Construction, Type System, Output & Validation)
  • Create comprehensive schema documentation using hybrid approach:
    • Auto-generated technical reference (docs/generated-schema.md) using json-schema-for-humans
    • Manual implementation guide (docs/schema-reference.md) with practical examples
  • Add automated schema documentation generation script (scripts/generate-schema-docs.mjs)
  • Update stats collection and README update scripts to use feature-based categorization
  • Update all documentation files with corrected file paths and cross-references

• Flatten test directory structure for easier parsing (287b1ec)

  • Move all test files to single level in tests/ directory
  • Update schema references from ../schema.json to ./schema.json
  • Update package.json validation paths to flat structure
  • Rewrite stats script to use metadata-based categorization
  • Update README.md paths from nested to flat structure
  • Fix categorization logic in collect-stats.sh

• Reorganize tests from level-based to feature-based structure (3d40163)

  Replace rigid 4-level hierarchy with flexible feature-based organization:

  • Core tests: essential-parsing (18 tests), comprehensive-parsing (30 tests), object-construction (8 tests)
  • Feature tests: dotted-keys (18 tests), comments (3 tests), processing (21 tests), typed-access (17 tests)
  • Integration tests: errors (5 tests)
  • Remove all legacy level-*.json files for cleaner structure
  • Add comprehensive API reference with dual access pattern support
  • Generalize stats script with fd auto-discovery and feature categorization
  • Update package.json validation to new structure only

  Total: 135 tests organized by implementation priority rather than arbitrary levels

• Enhance bash scripts with charm gum interactivity (9cdedab)

  • Add --interactive flag to collect-stats.sh for styled output
  • Add --yes flag to update-readme.sh for automation compatibility
  • Implement change preview with confirmation prompts
  • Add progress spinners and colorful styling throughout
  • Remove backup functionality (rely on git instead)
  • Add gum to .mise.toml configuration
  • Maintain backward compatibility with existing npm scripts

• Update settings after cleanup (06bcfd1)

• Update local settings (f571d12)

• Add gitignore and remove node_modules from tracking (2e57e1d)

• Implement readme automation with jq/sd and mise dependency management (7484064)

• Implement comprehensive schema validation with inheritance (21698ec)

• Add npm-based schema validation infrastructure (b1723ab)

• Implement decorative section headers with minimal api (cb2cc35)

  Core Implementation:

  • Add SectionGroup type with header and entries fields
  • Implement is_section_header() detection function
  • Implement group_by_sections() with recursive grouping algorithm
  • Detection rule: empty key + value starts with "="

  Comprehensive Test Coverage (12 new tests):

  • Basic section headers (double/triple equals)
  • Multiple sections with mixed content
  • Edge cases: empty sections, end-of-file headers, spacing
  • Multiline headers (indented and unindented continuation)
  • Integration with comments and list items
  • All 104 tests passing

  Documentation Updates:

  • Add Level 2.5 architectural positioning
  • Clarify colon convention is optional, not API requirement
  • Document user-defined helper function examples
  • Explain multiline behavior and CCL spec compliance
  • Add hybrid processing approach examples

  Design Philosophy:

  • Minimal core API (2 functions + 1 type)
  • Users implement own filtering/searching helpers
  • Maximum flexibility with standard list operations
  • Follows existing comment filtering patterns

• Implement comprehensive algebraic property testing for ccl (6f9bf38)

  Add 12 algebraic tests verifying CCL's mathematical foundations:

  • Monoid properties (identity element tests)
  • Semigroup properties (associativity tests)
  • Composition properties (closure, structure preservation)
  • Text concatenation equivalence
  • Unicode, comment, and nested structure stability

  Design decisions documented in DEV.md:

  • Use semantic empty (entry list []) as monoid identity
  • Separate core parsing from higher-level semantic tests
  • Fixed comprehensive JSON test cases over property-based testing

  All 12 algebraic property tests pass, confirming CCL's category theory foundations.

• Add comprehensive polishing improvements (abf3efa)

  • Enhanced error messages with contextual hints and suggestions
  • Created comprehensive CCL examples documentation with core vs Gleam separation
  • Fixed typed parsing whitespace test to match CCL specification
  • Added benchmarking framework with performance demonstration
  • Implemented object construction performance testing

• Add tdd framework for ccl typed parsing feature (184b9f0)