keymap-align 0.2.0__py3-none-any.whl

keymap_align/__init__.py

@@ -0,0 +1 @@
+"""keymap-align: ZMK keymap alignment tool."""

keymap_align/align.py

@@ -0,0 +1,693 @@
+import json
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from keymap_align.config import DEFAULT_INDENT_SIZE
+from keymap_align.config import DEFAULT_PADDING
+
+
+class Colors:
+    """ANSI Color codes for terminal output."""
+
+    RESET = '\033[0m'
+    GREEN = '\033[92m'
+    BLUE = '\033[94m'
+    ORANGE = '\033[38;5;208m'
+    RED = '\033[91m'
+    YELLOW = '\033[93m'
+    CYAN = '\033[96m'
+    BOLD = '\033[1m'
+    PURPLE = '\033[95m'
+    MAGENTA = '\033[38;5;198m'
+    GRAY = '\033[90m'
+    BRIGHT_GREEN = '\033[38;5;46m'
+
+
+DIMMED_BEHAVIORS = {'&none', '&trans'}
+KEYPRESS_BEHAVIORS = {'&kp'}
+STOCK_ZMK_BEHAVIORS = {
+    '&lt',
+    '&mt',
+    '&mo',
+    '&to',
+    '&tog',
+    '&sl',
+    '&sk',
+    '&caps_word',
+    '&bt',
+    '&rgb_ug',
+    '&sys_reset',
+    '&bootloader',
+    '&out',
+    '&mkp',
+    '&mmv',
+    '&msc',
+    '&mwh',  # Mouse behaviors
+    '&td',
+    '&key_repeat',
+    '&gresc',
+    '&sticky_key',  # Other stock behaviors
+}
+
+# Behaviors that take multiple parameters (including behavior parameters)
+MULTI_PARAM_BEHAVIORS = {'&hmr', '&hml', '&hmrt', '&hmlt', '&ltl', '&ltr', '&td'}
+
+
+def get_behavior_color(behavior):
+    if not behavior.startswith('&'):
+        return Colors.RESET
+
+    behavior_name = behavior.split()[0].lower()
+
+    if behavior_name in DIMMED_BEHAVIORS:
+        return Colors.GRAY
+    if behavior_name in KEYPRESS_BEHAVIORS:
+        return Colors.ORANGE
+    if behavior_name in STOCK_ZMK_BEHAVIORS:
+        return Colors.PURPLE
+    # Custom/user-defined behaviors (home row mods, custom macros, etc.)
+    return Colors.MAGENTA
+
+
+def extract_bindings_from_content(bindings_content, binding_macros=frozenset()):
+    """Split a bindings array's text into bindings, each starting at an `&behavior` or a name in `binding_macros`."""
+    if not bindings_content:
+        return []
+
+    content = re.sub(r'//.*$', '', bindings_content, flags=re.MULTILINE)
+    content = re.sub(r'/\*.*?\*/', '', content, flags=re.DOTALL)
+    tokens = [token.rstrip('>;') for token in content.split() if token.rstrip('>;')]
+    return parse_tokens_into_bindings(tokens, binding_macros)
+
+
+def parse_tokens_into_bindings(tokens, binding_macros):
+    bindings = []
+    i = 0
+
+    while i < len(tokens):
+        if tokens[i].startswith('&') or tokens[i] in binding_macros:
+            binding_parts = [tokens[i]]
+            behavior = binding_parts[0].lower()
+            i += 1
+
+            if behavior in MULTI_PARAM_BEHAVIORS:
+                i = handle_multi_param_behavior(tokens, i, binding_parts, binding_macros)
+            else:
+                i = handle_standard_behavior(tokens, i, binding_parts, binding_macros)
+
+            bindings.append(' '.join(binding_parts))
+        else:
+            i += 1
+
+    return bindings
+
+
+def handle_multi_param_behavior(tokens, i, binding_parts, binding_macros):
+    """Handle behaviors that can take multiple parameters including behavior parameters."""
+    behavior = binding_parts[0].lower()
+    param_count = 0
+
+    # Define parameter patterns for different behaviors
+    # Each behavior can have different valid parameter patterns
+    behavior_param_rules = {
+        '&hmr': [1, 2],  # Can take 1 or 2 parameters
+        '&hml': [1, 2],  # Can take 1 or 2 parameters
+        '&hmrt': [1, 2],  # Can take 1 or 2 parameters
+        '&hmlt': [1, 2],  # Can take 1 or 2 parameters
+        '&ltl': [2],  # Always takes 2 parameters
+        '&ltr': [2],  # Always takes 2 parameters
+        '&td': [1, 2],  # Can take 1 or 2 parameters
+    }
+
+    max_params = max(behavior_param_rules.get(behavior, [2]))  # Default to 2 if not specified
+
+    while i < len(tokens) and param_count < max_params:
+        if tokens[i] in binding_macros:
+            break
+        if tokens[i].startswith('&'):
+            # For behaviors like &hmr, &hml, &hmrt, &hmlt, a behavior can be the second parameter
+            if param_count == 0 or (param_count == 1 and behavior in ('&hmr', '&hml', '&hmrt', '&hmlt')):
+                binding_parts.append(tokens[i])
+                i += 1
+                param_count += 1
+
+                # If this behavior parameter has its own parameter, include it
+                # but only if we're still under the max params and the next token isn't a behavior
+                if param_count < max_params and i < len(tokens) and not tokens[i].startswith('&'):
+                    binding_parts.append(tokens[i])
+                    i += 1
+                    param_count += 1
+            else:
+                break  # This is the next binding
+        else:
+            binding_parts.append(tokens[i])
+            i += 1
+            param_count += 1
+
+    return i
+
+
+def handle_standard_behavior(tokens, i, binding_parts, binding_macros):
+    """Handle standard behaviors with simple parameters."""
+    # Collect parameters until the next binding starts or the tokens run out
+    while i < len(tokens) and not tokens[i].startswith('&') and tokens[i] not in binding_macros:
+        binding_parts.append(tokens[i])
+        i += 1
+
+    return i
+
+
+class KeymapError(ValueError):
+    """A keymap the aligner cannot rewrite without losing or misplacing text."""
+
+
+@dataclass
+class Layer:
+    """A child node of the `keymap` node that holds a `bindings = < … >` array.
+
+    `start` and `end` bound the text between the array's `<` and `>`, which is the only
+    text a rewrite replaces. `indent` is the leading whitespace of the line holding
+    `bindings`, where the rewritten `>` goes.
+    """
+
+    name: str
+    display_name: str | None
+    bindings: list[str]
+    start: int
+    end: int
+    indent: str
+
+
+COMMENT_OR_STRING = re.compile(r'//[^\n]*|/\*.*?\*/|"(?:[^"\\\n]|\\.)*"', re.DOTALL)
+KEYMAP_NODE = re.compile(r'(?<![\w,.+@&#-])keymap\s*\{')
+BINDINGS_PROPERTY = re.compile(r'\s*bindings\s*=\s*<')
+DISPLAY_NAME_PROPERTY = re.compile(r'\s*display-name\s*=\s*"')
+BINDING_MACRO = re.compile(r'^[ \t]*#[ \t]*define[ \t]+(\w+)[ \t]+&', re.MULTILINE)
+
+
+def blank_comments_and_strings(text):
+    """Return `text` with every comment, and every string between its quotes, turned to spaces.
+
+    Newlines stay, so an offset into the result is the same offset into `text`. A brace,
+    `<` or `;` inside a comment or a display-name then reads as nothing.
+    """
+
+    def blank(match):
+        found = match.group(0)
+        if found.startswith('"'):
+            return '"' + re.sub(r'[^\n]', ' ', found[1:-1]) + '"'
+        return re.sub(r'[^\n]', ' ', found)
+
+    return COMMENT_OR_STRING.sub(blank, text)
+
+
+def line_number(text, offset):
+    return text.count('\n', 0, offset) + 1
+
+
+def closing_brace(masked, open_brace):
+    depth = 0
+    for i in range(open_brace, len(masked)):
+        if masked[i] == '{':
+            depth += 1
+        elif masked[i] == '}':
+            depth -= 1
+            if depth == 0:
+                return i
+    raise KeymapError(f'the brace on line {line_number(masked, open_brace)} is never closed')
+
+
+def statements(masked, start, end):
+    """Yield `(start, end, body)` for each property and child node directly inside `masked[start:end]`.
+
+    A property runs to its `;`, and its body is None. A child node's statement runs to its
+    opening brace, and its body is the `(start, end)` span between its braces.
+    """
+    statement_start = start
+    i = start
+    while i < end:
+        char = masked[i]
+        if char == '{':
+            close = closing_brace(masked, i)
+            yield statement_start, i, (i + 1, close)
+            i = statement_start = close + 1
+            continue
+        if char == ';':
+            yield statement_start, i, None
+            statement_start = i + 1
+        i += 1
+
+
+def closing_angle(masked, open_angle, end):
+    """Find the `>` closing the cell array opened at `open_angle`, skipping any inside parentheses."""
+    depth = 0
+    for i in range(open_angle + 1, end):
+        if masked[i] == '(':
+            depth += 1
+        elif masked[i] == ')':
+            depth -= 1
+        elif masked[i] == '>' and depth == 0:
+            return i
+    raise KeymapError(f'the bindings array opened on line {line_number(masked, open_angle)} is never closed')
+
+
+def read_layer(keymap_content, masked, name, body_start, body_end, binding_macros):
+    """Read one child node of `keymap`, or return None when it holds no `bindings` array."""
+    display_name = None
+    array = None
+    for start, end, body in statements(masked, body_start, body_end):
+        if body is not None:
+            continue
+        statement = masked[start:end]
+        if match := DISPLAY_NAME_PROPERTY.match(statement):
+            open_quote = start + match.end() - 1
+            close_quote = masked.find('"', open_quote + 1, end)
+            if close_quote != -1:
+                display_name = keymap_content[open_quote + 1 : close_quote]
+        elif match := BINDINGS_PROPERTY.match(statement):
+            open_angle = start + match.end() - 1
+            close_angle = closing_angle(masked, open_angle, end)
+            if masked[close_angle + 1 : end].strip():
+                raise KeymapError(
+                    f"layer '{name}' continues its bindings past the '>' on line {line_number(masked, close_angle)}, "
+                    'and the aligner reads a single < > array'
+                )
+            keyword = start + len(statement) - len(statement.lstrip())
+            array = (open_angle + 1, close_angle, keyword)
+
+    if array is None:
+        return None
+    array_start, array_end, keyword = array
+    line = keymap_content[keymap_content.rfind('\n', 0, keyword) + 1 : keyword]
+    return Layer(
+        name=name,
+        display_name=display_name,
+        bindings=extract_bindings_from_content(keymap_content[array_start:array_end], binding_macros),
+        start=array_start,
+        end=array_end,
+        indent=line[: len(line) - len(line.lstrip(' \t'))],
+    )
+
+
+def find_layers(keymap_content):
+    """Return each child node of the `keymap` node that holds a `bindings` array, in file order.
+
+    A node name is whatever precedes its opening brace, minus any label, so a name may hold
+    any character devicetree allows. A name the file `#define`s to a binding, such as
+    `XXX` for `&none`, is a binding of its own. Raises KeymapError when there is no `keymap`
+    node, a brace or a `bindings` array is never closed, or a `bindings` property holds more
+    than one array.
+    """
+    masked = blank_comments_and_strings(keymap_content)
+    binding_macros = frozenset(BINDING_MACRO.findall(masked))
+    keymap_match = KEYMAP_NODE.search(masked)
+    if keymap_match is None:
+        raise KeymapError("no 'keymap {' node found")
+    open_brace = keymap_match.end() - 1
+    close_brace = closing_brace(masked, open_brace)
+
+    layers = []
+    for start, end, body in statements(masked, open_brace + 1, close_brace):
+        if body is None:
+            continue
+        header = masked[start:end].split()
+        name = header[-1].rsplit(':', 1)[-1] if header else ''
+        layer = read_layer(keymap_content, masked, name, *body, binding_macros)
+        if layer is not None:
+            layers.append(layer)
+    return layers
+
+
+def layers_by_name(layers):
+    return {layer.name: {'bindings': layer.bindings, 'display_name': layer.display_name} for layer in layers}
+
+
+def extract_all_layers(keymap_content):
+    """Map each layer's node name to its bindings and display-name."""
+    return layers_by_name(find_layers(keymap_content))
+
+
+def load_layout(layout_file):
+    try:
+        with open(layout_file) as f:
+            layout = json.load(f)
+
+        if 'layout' not in layout:
+            print("Error: Layout file must contain a 'layout' field", file=sys.stderr)
+            return None
+
+        return layout
+
+    except FileNotFoundError:
+        print(f"Error: Layout file '{layout_file}' not found.", file=sys.stderr)
+        return None
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in layout file '{layout_file}': {e}", file=sys.stderr)
+        return None
+
+
+def build_layer_structure(layers, layout):
+    """
+    Organize layer bindings according to the keyboard layout matrix.
+    """
+    layout_matrix = layout['layout']
+    structured_layers = {}
+
+    for layer_name, layer_data in layers.items():
+        bindings = layer_data['bindings']
+        layer_rows = []
+        binding_index = 0
+
+        for row in layout_matrix:
+            row_bindings = []
+            for cell in row:
+                if cell == 'X':
+                    if binding_index < len(bindings):
+                        row_bindings.append(bindings[binding_index])
+                        binding_index += 1
+                    else:
+                        row_bindings.append(None)  # Missing binding
+                else:
+                    row_bindings.append(None)  # Empty position
+            layer_rows.append(row_bindings)
+
+        structured_layers[layer_name] = {'rows': layer_rows, 'display_name': layer_data['display_name']}
+
+    return structured_layers
+
+
+def calculate_column_widths(structured_layers, layout, padding=DEFAULT_PADDING):
+    layout_matrix = layout['layout']
+    num_columns = len(layout_matrix[0]) if layout_matrix else 0
+    column_widths = [0] * num_columns
+
+    # Find the maximum width needed for each column across all layers
+    for layer_data in structured_layers.values():
+        layer_rows = layer_data['rows']
+        for row in layer_rows:
+            for col_idx, binding in enumerate(row):
+                if binding is not None:
+                    column_widths[col_idx] = max(column_widths[col_idx], len(binding))
+
+    return [width + padding for width in column_widths]
+
+
+def format_binding_rows(layer_rows, column_widths, indent_size=DEFAULT_INDENT_SIZE):
+    """Render one layer's grid as lines of text, each cell padded to its column's width.
+
+    Each line starts with `indent_size` spaces. A gap or a missing binding is a blank cell.
+    """
+    lines = []
+    for row in layer_rows:
+        row_content = ' ' * indent_size
+        for col_idx, binding in enumerate(row):
+            row_content += (binding or '').ljust(column_widths[col_idx])
+        lines.append(row_content.rstrip())
+    return lines
+
+
+def first_lost_token(original, realigned):
+    """Return the first token of `original`, as a match, that `realigned` does not hold at the same position."""
+    realigned_tokens = realigned.split()
+    for index, token in enumerate(re.finditer(r'\S+', original)):
+        if index >= len(realigned_tokens) or token.group(0) != realigned_tokens[index]:
+            return token
+    return None
+
+
+def realign_bindings(keymap_content, layers, structured_layers, column_widths, layout, indent_size=DEFAULT_INDENT_SIZE):
+    """Return `keymap_content` with the inside of each layer's `bindings` array realigned.
+
+    Only the text between each array's `<` and `>` changes, and the `>` goes on its own line
+    at the indentation of the line holding `bindings`. Raises KeymapError, naming every layer
+    at fault, when a layer holds more bindings than the layout has keys, or when its array
+    holds text the realigned rows would not reproduce, such as a comment.
+    """
+    key_count = sum(row.count('X') for row in layout['layout'])
+    problems = []
+    pieces = []
+    cursor = 0
+    for layer in layers:
+        if len(layer.bindings) > key_count:
+            problems.append(f"layer '{layer.name}' holds {len(layer.bindings)} bindings, but the layout has {key_count} keys")
+            continue
+        rows = format_binding_rows(structured_layers[layer.name]['rows'], column_widths, indent_size)
+        realigned = '\n' + '\n'.join(rows) + '\n' + layer.indent
+        lost = first_lost_token(keymap_content[layer.start : layer.end], realigned)
+        if lost is not None:
+            problems.append(
+                f"layer '{layer.name}' holds '{lost.group(0)}' on line {line_number(keymap_content, layer.start + lost.start())} "
+                'inside its bindings, which realigning would drop'
+            )
+            continue
+        pieces.append(keymap_content[cursor : layer.start])
+        pieces.append(realigned)
+        cursor = layer.end
+
+    if problems:
+        raise KeymapError('\n'.join(problems))
+    pieces.append(keymap_content[cursor:])
+    return ''.join(pieces)
+
+
+def visual_debug_print_layout(layout):
+    """Print keyboard layout structure for human inspection."""
+    print(f'\n{Colors.GREEN}{Colors.BOLD}{"=" * 70}')
+    print('ZMK KEYMAP ALIGNMENT DEBUG')
+    print(f'{"=" * 70}{Colors.RESET}')
+
+    print(f'\n{Colors.CYAN}KEYBOARD LAYOUT INFORMATION{Colors.RESET}')
+    print('─' * 50)
+
+    layout_matrix = layout['layout']
+    rows = len(layout_matrix)
+    columns = len(layout_matrix[0]) if layout_matrix else 0
+    total_keys = sum(sum(1 for cell in row if cell == 'X') for row in layout_matrix)
+
+    print(f'  Layout name: {Colors.YELLOW}{layout.get("name", "Unknown")}{Colors.RESET}')
+    print(f'  Dimensions:  {Colors.YELLOW}{rows} rows x {columns} columns{Colors.RESET}')
+    print(f'  Total keys:  {Colors.YELLOW}{total_keys}{Colors.RESET}')
+
+    print(f'\n{Colors.CYAN}LAYOUT MATRIX{Colors.RESET} (X = key position, - = empty)')
+    print('─' * 50)
+
+    for row_idx, row in enumerate(layout_matrix):
+        row_display = []
+        for col_idx, cell in enumerate(row):
+            if cell == 'X':
+                row_display.append(f'{Colors.GREEN}[{col_idx:2d}]{Colors.RESET}')
+            else:
+                row_display.append('    ')
+        print(f'  Row {row_idx:2d}: ' + ' '.join(row_display))
+
+
+def visual_debug_print_layer_bindings(layers, layout, column_widths):
+    """Print layer bindings in keyboard layout matrix format."""
+    print(f'\n{Colors.CYAN}COLUMN WIDTHS{Colors.RESET}')
+    print('─' * 50)
+    print('  Col: ' + ' '.join(f'{i:2d}' for i in range(len(column_widths))))
+    print('  Width: ' + ' '.join(f'{width:2d}' for width in column_widths))
+
+    print(f'\n{Colors.CYAN}LAYER BINDINGS LAYOUT{Colors.RESET}')
+    print('─' * 50)
+
+    layout_matrix = layout['layout']
+
+    for layer_name, layer_data in layers.items():
+        bindings = layer_data['bindings']
+        display_name = layer_data['display_name']
+        layer_title = f'Layer: {layer_name}'
+        if display_name:
+            layer_title += f' ("{display_name}")'
+
+        print(f'\n  {Colors.BLUE}{Colors.BOLD}{layer_title}{Colors.RESET}')
+        print(f'     Total bindings: {Colors.YELLOW}{len(bindings)}{Colors.RESET}')
+
+        # Calculate layer-specific column widths for compact display
+        layer_column_widths = calculate_layer_column_widths(layout_matrix, bindings)
+
+        # Display the layer with proper visual alignment
+        print_layer_with_alignment(layout_matrix, bindings, layer_column_widths)
+
+
+def calculate_layer_column_widths(layout_matrix, bindings):
+    """Calculate column widths optimized for a single layer."""
+    layer_column_widths = [0] * len(layout_matrix[0])
+    binding_index = 0
+
+    for row in layout_matrix:
+        for col_idx, cell in enumerate(row):
+            if cell == 'X' and binding_index < len(bindings):
+                binding = bindings[binding_index]
+                layer_column_widths[col_idx] = max(layer_column_widths[col_idx], len(binding) + 2)
+                binding_index += 1
+
+    return layer_column_widths
+
+
+def print_layer_with_alignment(layout_matrix, bindings, layer_column_widths):
+    """Print a single layer with proper visual keyboard alignment."""
+    binding_index = 0
+
+    for row_idx, row in enumerate(layout_matrix):
+        if not any(cell == 'X' for cell in row):
+            continue  # Skip rows with no bindings
+
+        row_display = []
+        for col_idx, cell in enumerate(row):
+            if cell == 'X':
+                if binding_index < len(bindings):
+                    binding = bindings[binding_index]
+                    colored_binding = colorize_binding(binding)
+                    display_text = f'[{colored_binding}]'
+                    # Account for color codes in padding calculation
+                    color_len = len(colored_binding) - len(binding)
+                    padded_text = display_text.ljust(layer_column_widths[col_idx] + color_len)
+                    row_display.append(padded_text)
+                    binding_index += 1
+                else:
+                    empty_text = f'[{Colors.RED}---{Colors.RESET}]'
+                    color_len = len(empty_text) - 3
+                    padded_text = empty_text.ljust(layer_column_widths[col_idx] + color_len)
+                    row_display.append(padded_text)
+            else:
+                row_display.append(' ' * layer_column_widths[col_idx])
+
+        print(f'     Row {row_idx:2d}: ' + ''.join(row_display).rstrip())
+
+
+def colorize_binding(binding):
+    """Apply appropriate color to a binding for display."""
+    if not binding.startswith('&'):
+        return binding
+
+    parts = binding.split()
+    behavior_color = get_behavior_color(binding)
+
+    if len(parts) > 1:
+        return f'{behavior_color}{parts[0]}{Colors.RESET} {" ".join(parts[1:])}'
+    return f'{behavior_color}{binding}{Colors.RESET}'
+
+
+def visual_debug_print_formatted_layers(structured_layers, column_widths, indent_size=DEFAULT_INDENT_SIZE):
+    """Print formatted layers with colored output for debugging."""
+    print(f'\n{Colors.CYAN}FORMATTED LAYERS OUTPUT{Colors.RESET}')
+    print('─' * 50)
+
+    for layer_name, layer_data in structured_layers.items():
+        rows = format_binding_rows(layer_data['rows'], column_widths, indent_size)
+
+        print(f'\n{Colors.BLUE}{layer_name}{Colors.RESET}')
+        print_colored_bindings('\n'.join(row.strip() for row in rows))
+
+
+def print_colored_bindings(clean_bindings):
+    """Print bindings with appropriate coloring applied."""
+
+    def replace_behavior(match):
+        behavior = match.group(0)
+        behavior_parts = behavior.split()
+        behavior_color = get_behavior_color(behavior)
+
+        if len(behavior_parts) > 1:
+            return f'{behavior_color}{behavior_parts[0]}{Colors.RESET} {" ".join(behavior_parts[1:])}'
+        return f'{behavior_color}{behavior}{Colors.RESET}'
+
+    behavior_pattern = r'&\w+(?:\s+[^&\s]+(?:\s+[^&\s]+)*)?'
+
+    for line in clean_bindings.split('\n'):
+        if line.strip():
+            colored_line = re.sub(behavior_pattern, replace_behavior, line)
+            print(f'  {colored_line}')
+
+
+def align_keymap_with_layout(
+    keymap_file,
+    layout_file,
+    output_file=None,
+    debug=False,
+    indent_size=DEFAULT_INDENT_SIZE,
+    padding=DEFAULT_PADDING,
+):
+    """Align keymap bindings according to keyboard layout.
+
+    Only the inside of each layer's `bindings` array is rewritten. A keymap that cannot be
+    rewritten without losing text is reported, and nothing is written.
+
+    Args:
+        keymap_file: Path to the keymap file
+        layout_file: Path to the layout JSON file
+        output_file: Optional output file path (default: modify in place)
+        debug: Print the layout and each layer's grid; write nothing
+        indent_size: Number of spaces before each binding row (default 4)
+        padding: Number of spaces between columns (default 2)
+    """
+    layout = load_layout(layout_file)
+    if layout is None:
+        return False
+
+    try:
+        keymap_content = Path(keymap_file).read_text()
+    except FileNotFoundError:
+        print(f"Error: Keymap file '{keymap_file}' not found.", file=sys.stderr)
+        return False
+
+    try:
+        layers = find_layers(keymap_content)
+    except KeymapError as e:
+        print(f'Error: {e}', file=sys.stderr)
+        return False
+    if not layers:
+        print('Error: No layers found in keymap file.', file=sys.stderr)
+        return False
+
+    names = [layer.name for layer in layers]
+    duplicates = sorted({name for name in names if names.count(name) > 1})
+    if duplicates:
+        print(f'Error: more than one layer node is named {", ".join(duplicates)}', file=sys.stderr)
+        return False
+
+    print(f'Found layers: {names}')
+    layer_data = layers_by_name(layers)
+    structured_layers = build_layer_structure(layer_data, layout)
+    column_widths = calculate_column_widths(structured_layers, layout, padding)
+
+    if debug:
+        visual_debug_print_layout(layout)
+        visual_debug_print_layer_bindings(layer_data, layout, column_widths)
+        visual_debug_print_formatted_layers(structured_layers, column_widths, indent_size)
+
+    try:
+        output_content = realign_bindings(keymap_content, layers, structured_layers, column_widths, layout, indent_size)
+    except KeymapError as e:
+        for problem in str(e).splitlines():
+            print(f'Error: {problem}', file=sys.stderr)
+        print('Nothing was written.', file=sys.stderr)
+        return False
+
+    if debug:
+        return True
+
+    for layer in layers:
+        print(f'Formatted {layer.name}: {len(layer.bindings)} bindings')
+
+    # Determine output destination
+    target_file = output_file or keymap_file
+
+    try:
+        Path(target_file).write_text(output_content)
+
+        if output_file:
+            print(f'Output written to: {output_file}')
+        else:
+            print(f'Keymap formatted in place: {keymap_file}')
+
+    except OSError as e:
+        print(f"Error writing to file '{target_file}': {e}", file=sys.stderr)
+        return False
+
+    print(f'Keymap aligned using layout: {layout_file}')
+    print('Alignment completed successfully!')
+    return True

keymap_align/cli.py

@@ -0,0 +1,168 @@
+"""Command-line interface for keymap-align."""
+
+import importlib.metadata
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from pyselfupdate import Config
+from pyselfupdate import notify
+from pyselfupdate.typercmd import run_update
+
+from keymap_align.align import align_keymap_with_layout
+from keymap_align.config import find_config_file
+from keymap_align.config import get_align_config
+from keymap_align.config import load_config
+from keymap_align.layout_resolver import get_bundled_layout_names
+from keymap_align.layout_resolver import resolve_layout
+
+ROOT_HELP = (
+    "Align a ZMK keymap so its bindings sit in columns matching the keyboard's physical shape. "
+    '`format` is the command to run, by hand or from an editor formatter. It rewrites the keymap '
+    'in place, taking the layout from a flag or from a keymap_align.toml beside the keymap. '
+    '`layouts list` names the boards that ship with the tool, which is what `format --layout` accepts.'
+    '\n\n'
+    'Run any partial command with no arguments or --help to see what comes next.'
+)
+
+ROOT_EPILOG = """
+Examples:
+
+[b]keymap-align format -k corne.keymap --layout corne42[/b] — align a keymap for a board that ships with the tool
+
+[b]keymap-align layouts list[/b] — the boards --layout accepts
+"""
+
+FORMAT_HELP = (
+    "Align a ZMK keymap so its bindings sit in columns matching the keyboard's physical shape. "
+    'The layout is what tells the aligner where the physical gaps are, so every run needs one: '
+    'name a bundled board with --layout, point at your own with --layout-file, or let a '
+    'keymap_align.toml beside the keymap supply it. A flag beats the config file. '
+    'Without --output the keymap is rewritten in place.'
+)
+
+FORMAT_EPILOG = """
+Examples:
+
+[b]keymap-align format -k corne.keymap --layout corne42[/b] — a board that ships with the tool
+
+[b]keymap-align format -k corne.keymap[/b] — layout named by keymap_align.toml beside the keymap
+
+[b]keymap-align format -k corne.keymap -l split34.json[/b] — a layout this repo owns
+
+[b]keymap-align format -k corne.keymap -o aligned.keymap[/b] — write elsewhere, leave the original
+"""
+
+# One config for `update` and the notice, so the notice never names a release `update` would not install.
+UPDATE_CONFIG = Config(tool='keymap-align', owner='datapointchris')
+
+app = typer.Typer(
+    name='keymap-align',
+    no_args_is_help=True,
+    help=ROOT_HELP,
+    epilog=ROOT_EPILOG,
+    add_completion=False,
+    context_settings={'help_option_names': ['-h', '--help']},
+)
+layouts_app = typer.Typer(
+    name='layouts',
+    no_args_is_help=True,
+    help='The keyboard layouts that ship with the tool, each one a name `format --layout` accepts.',
+)
+app.add_typer(layouts_app, name='layouts')
+
+
+def show_version(asked: bool) -> None:
+    if not asked:
+        return
+    try:
+        version = importlib.metadata.version('keymap-align')
+    except importlib.metadata.PackageNotFoundError:
+        version = 'unknown'
+    print(f'keymap-align {version}')
+    raise typer.Exit()
+
+
+@app.callback()
+def root(
+    ctx: typer.Context,
+    version: Annotated[
+        bool | None,
+        typer.Option('--version', callback=show_version, is_eager=True, help='Show the installed version and exit.'),
+    ] = None,
+) -> None:
+    # `update` is already installing the release the notice would name.
+    if ctx.invoked_subcommand != 'update':
+        notify(UPDATE_CONFIG)
+
+
+@app.command('format', help=FORMAT_HELP, short_help="Align a keymap's bindings into the columns of a layout.", epilog=FORMAT_EPILOG)
+def format_keymap(
+    keymap: Annotated[
+        str,
+        typer.Option('--keymap', '-k', help='The .keymap file to align.', rich_help_panel='Input'),
+    ],
+    layout: Annotated[
+        str | None,
+        typer.Option('--layout', help='Bundled layout name, e.g. corne42.', rich_help_panel='Layout'),
+    ] = None,
+    layout_file: Annotated[
+        str | None,
+        typer.Option('--layout-file', '-l', help='Layout JSON to use instead of a bundled one.', rich_help_panel='Layout'),
+    ] = None,
+    output: Annotated[
+        str | None,
+        typer.Option('--output', '-o', help='Write here instead of rewriting the keymap in place.', rich_help_panel='Output'),
+    ] = None,
+    debug: Annotated[
+        bool,
+        typer.Option('--debug', help='Show the column math behind each alignment decision.', rich_help_panel='Output'),
+    ] = False,
+) -> None:
+    keymap_path = Path(keymap).resolve()
+    config = {}
+    config_path = find_config_file(keymap_path.parent)
+    if config_path:
+        try:
+            config = load_config(config_path)
+        except Exception as e:
+            print(f'Warning: Failed to load config from {config_path}: {e}', file=sys.stderr)
+
+    align_config = get_align_config(config, config_path)
+
+    try:
+        layout_context = resolve_layout(layout, layout_file, align_config.layout)
+    except ValueError as e:
+        print(f'Error: {e}', file=sys.stderr)
+        raise typer.Exit(1) from e
+
+    with layout_context as layout_path:
+        success = align_keymap_with_layout(
+            keymap,
+            layout_path,
+            output,
+            debug,
+            indent_size=align_config.indent_size,
+            padding=align_config.padding,
+        )
+    raise typer.Exit(0 if success else 1)
+
+
+@layouts_app.command('list')
+def list_layouts() -> None:
+    """Print the name of every bundled layout, one per line."""
+    for name in get_bundled_layout_names():
+        print(name)
+
+
+@app.command(rich_help_panel='Manage')
+def update(
+    check_only: Annotated[bool, typer.Option('--check', help='Report whether an update is available without installing it.')] = False,
+) -> None:
+    """Update keymap-align to the latest release."""
+    run_update(UPDATE_CONFIG, check_only=check_only)
+
+
+if __name__ == '__main__':
+    app()

keymap_align/config.py

@@ -0,0 +1,135 @@
+"""Config file discovery and loading for keymap-align."""
+
+import subprocess  # nosec B404
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+# Default configuration values
+DEFAULT_INDENT_SIZE = 4
+DEFAULT_PADDING = 2
+
+
+@dataclass
+class AlignConfig:
+    """Configuration for keymap alignment."""
+
+    layout: str | None = None
+    indent_size: int = DEFAULT_INDENT_SIZE
+    padding: int = DEFAULT_PADDING
+
+
+def get_git_root(start_path: Path) -> Path | None:
+    """Get the git repository root for a path, if it exists."""
+    try:
+        result = subprocess.run(  # nosec B603, B607
+            ['git', 'rev-parse', '--show-toplevel'],
+            cwd=start_path,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return Path(result.stdout.strip())
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+
+def find_config_file(start_path: Path) -> Path | None:
+    """Search up directory tree for keymap_align.toml.
+
+    Stops at git root or filesystem root.
+
+    Args:
+        start_path: Directory to start searching from
+
+    Returns:
+        Path to config file if found, None otherwise
+    """
+    start_path = start_path.resolve()
+    git_root = get_git_root(start_path)
+
+    current = start_path
+    while True:
+        config_path = current / 'keymap_align.toml'
+        if config_path.is_file():
+            return config_path
+
+        # Stop at git root if we have one
+        if git_root and current == git_root:
+            break
+
+        # Stop at filesystem root
+        parent = current.parent
+        if parent == current:
+            break
+
+        current = parent
+
+    return None
+
+
+def load_config(config_path: Path) -> dict:
+    """Load and parse keymap_align.toml.
+
+    Args:
+        config_path: Path to the config file
+
+    Returns:
+        Parsed config dictionary
+
+    Raises:
+        FileNotFoundError: If config file doesn't exist
+        tomllib.TOMLDecodeError: If config file is invalid TOML
+    """
+    with config_path.open('rb') as f:
+        return tomllib.load(f)
+
+
+def resolve_config_layout(config: dict, config_path: Path) -> str | None:
+    """Resolve layout value from config.
+
+    If layout is a relative path, resolve relative to config file location.
+    If layout is a name (no path separators), return as-is (bundled lookup).
+
+    Args:
+        config: Parsed config dictionary
+        config_path: Path to the config file (for resolving relative paths)
+
+    Returns:
+        Layout value (name or resolved path), or None if not specified
+    """
+    layout = config.get('layout')
+    if layout is None:
+        return None
+
+    # Check if it's a path (contains separator or .json extension)
+    if '/' in layout or '\\' in layout or layout.endswith('.json'):
+        # It's a path - resolve relative to config file location
+        layout_path = Path(layout)
+        if not layout_path.is_absolute():
+            layout_path = config_path.parent / layout_path
+        return str(layout_path.resolve())
+
+    # It's a bundled layout name - return as-is
+    return layout
+
+
+def get_align_config(config: dict, config_path: Path | None) -> AlignConfig:
+    """Build AlignConfig from parsed config dictionary.
+
+    Args:
+        config: Parsed config dictionary
+        config_path: Path to the config file (for resolving relative paths)
+
+    Returns:
+        AlignConfig with values from config or defaults
+    """
+    layout = resolve_config_layout(config, config_path) if config_path else config.get('layout')
+    indent_size = config.get('indent_size', DEFAULT_INDENT_SIZE)
+    padding = config.get('padding', DEFAULT_PADDING)
+
+    return AlignConfig(
+        layout=layout,
+        indent_size=indent_size,
+        padding=padding,
+    )

keymap_align/layout_resolver.py

@@ -0,0 +1,87 @@
+"""Layout resolution for keymap-align.
+
+Handles bundled layouts and layout path resolution.
+"""
+
+import contextlib
+import importlib.resources
+from pathlib import Path
+
+
+def get_bundled_layout_names() -> list[str]:
+    """Return list of bundled layout names (without .json extension)."""
+    layouts_package = importlib.resources.files('keymap_align.layouts')
+    names = [item.name[:-5] for item in layouts_package.iterdir() if item.name.endswith('.json')]
+    return sorted(names)
+
+
+def bundled_layout_path(name: str) -> contextlib.AbstractContextManager[Path]:
+    """Return a context manager yielding a filesystem path to a bundled layout.
+
+    The path is valid only inside the `with` block. A package imported from a zip has no
+    file on disk, so `importlib.resources.as_file` writes a temporary copy for the block
+    and deletes it when the block exits.
+
+    Args:
+        name: Layout name without .json extension (e.g., 'corne42')
+
+    Raises:
+        ValueError: If layout name is not found in bundled layouts
+    """
+    layout_file = importlib.resources.files('keymap_align.layouts').joinpath(f'{name}.json')
+
+    if not layout_file.is_file():
+        available = get_bundled_layout_names()
+        raise ValueError(f"Unknown bundled layout '{name}'. Available: {', '.join(available)}")
+
+    return importlib.resources.as_file(layout_file)
+
+
+def is_file_path(value: str) -> bool:
+    """Check if a value looks like a file path rather than a layout name."""
+    return '/' in value or '\\' in value or value.endswith('.json')
+
+
+def resolve_layout(
+    layout_arg: str | None,
+    layout_file_arg: str | None,
+    config_layout: str | None,
+) -> contextlib.AbstractContextManager[Path]:
+    """Resolve layout to a file path based on precedence rules.
+
+    Precedence: --layout-file > --layout > config > error
+
+    If a value looks like a path (contains / or .json), treat as file path.
+    Otherwise, look up as bundled layout name.
+
+    Args:
+        layout_arg: Value from --layout argument (bundled name or path)
+        layout_file_arg: Value from --layout-file argument (explicit file path)
+        config_layout: Value from config file (bundled name or path)
+
+    Returns:
+        A context manager yielding the layout file's path, which stays valid until the
+        `with` block exits. A bundled layout may be a temporary copy.
+
+    Raises:
+        ValueError: If no layout specified or layout not found
+    """
+    # Determine which value to use based on precedence
+    if layout_file_arg is not None:
+        # --layout-file is always a file path
+        return contextlib.nullcontext(Path(layout_file_arg))
+
+    if layout_arg is not None:
+        value = layout_arg
+    elif config_layout is not None:
+        value = config_layout
+    else:
+        raise ValueError(
+            'No layout specified. Use --layout <name> for bundled layouts, '
+            '--layout-file <path> for custom layouts, or create keymap_align.toml'
+        )
+
+    # Resolve the value - either as a path or bundled name
+    if is_file_path(value):
+        return contextlib.nullcontext(Path(value))
+    return bundled_layout_path(value)

keymap_align/layouts/corne42.json

@@ -0,0 +1,15 @@
+{
+  "name": "Corne 42 Layout",
+  "layout": [
+    ["X", "X", "X", "X", "X", "X", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["-", "-", "-", "-", "X", "X", "X", "X", "X", "X", "-", "-", "-", "-"]
+  ],
+  "key_positions": [
+    ["0",  "1",  "2",  "3",  "4",  "5",  "-",  "-",  "6",  "7",  "8",  "9",  "10", "11"],
+    ["12", "13", "14", "15", "16", "17", "-",  "-",  "18", "19", "20", "21", "22", "23"],
+    ["24", "25", "26", "27", "28", "29", "-",  "-",  "30", "31", "32", "33", "34", "35"],
+    ["-",  "-",  "-",  "-",  "36", "37", "38", "39", "40", "41", "-",  "-",  "-",  "-"]
+  ]
+}

keymap_align/layouts/glove80.json

@@ -0,0 +1,19 @@
+{
+  "name": "Glove80 Layout",
+  "layout": [
+    ["X", "X", "X", "X", "X", "-", "-", "-", "-", "-", "-", "-", "-", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "-", "-", "-", "-", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "-", "-", "-", "-", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "-", "-", "-", "-", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "X", "X", "X", "X", "X", "X", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "-", "X", "X", "X", "X", "X", "X", "-", "X", "X", "X", "X", "X"]
+  ],
+  "key_positions": [
+    ["0",  "1",  "2",  "3",  "4",  "-",  "-",  "-",  "-",  "-",  "-",  "-",  "-",  "5",  "6",  "7",  "8",  "9"],
+    ["10", "11", "12", "13", "14", "15", "-",  "-",  "-",  "-",  "-",  "-",  "16", "17", "18", "19", "20", "21"],
+    ["22", "23", "24", "25", "26", "27", "-",  "-",  "-",  "-",  "-",  "-",  "28", "29", "30", "31", "32", "33"],
+    ["34", "35", "36", "37", "38", "39", "-",  "-",  "-",  "-",  "-",  "-",  "40", "41", "42", "43", "44", "45"],
+    ["46", "47", "48", "49", "50", "51", "-",  "-",  "-",  "-",  "-",  "-",  "58", "59", "60", "61", "62", "63"],
+    ["64", "65", "66", "67", "68", "-",  "52", "53", "54", "55", "56", "57", "-",  "75", "76", "77", "78", "79"]
+  ]
+}

keymap_align/layouts/piantor.json

@@ -0,0 +1,15 @@
+{
+  "name": "Piantor Pro BT 42 Layout",
+  "layout": [
+    ["X", "X", "X", "X", "X", "X", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["-", "-", "-", "-", "X", "X", "X", "X", "X", "X", "-", "-", "-", "-"]
+  ],
+  "key_positions": [
+    ["0",  "1",  "2",  "3",  "4",  "5",  "-",  "-",  "6",  "7",  "8",  "9",  "10", "11"],
+    ["12", "13", "14", "15", "16", "17", "-",  "-",  "18", "19", "20", "21", "22", "23"],
+    ["24", "25", "26", "27", "28", "29", "-",  "-",  "30", "31", "32", "33", "34", "35"],
+    ["-",  "-",  "-",  "-",  "36", "37", "38", "39", "40", "41", "-",  "-",  "-",  "-"]
+  ]
+}

keymap_align-0.2.0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.5
+Name: keymap-align
+Version: 0.2.0
+Summary: ZMK keymap alignment tool for custom mechanical keyboards
+Project-URL: Repository, https://github.com/datapointchris/keymap-align
+Author-email: Chris Birch <datapointchris@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: alignment,firmware,keyboard,keymap,zmk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.13
+Requires-Dist: pyselfupdate[typer]>=0.5.4
+Requires-Dist: typer>=0.12.0
+Description-Content-Type: text/markdown
+
+# keymap-align
+
+ZMK keymap alignment tool for custom mechanical keyboards. Parses `.keymap` files and aligns bindings according to physical keyboard layout definitions, producing consistently formatted keymaps.
+
+## Overview
+
+keymap-align reads ZMK keymap files and a JSON layout definition, then reformats the `bindings = <...>` blocks so that each key binding aligns to its physical column position on the keyboard. This makes keymaps easier to read and maintain across different layer definitions.
+
+**Supports:**
+
+- Simple bindings: `&kp A`, `&trans`, `&none`
+- Multi-parameter behaviors: `&hml LCTRL A`, `&lt 1 SPACE`
+- Nested behaviors such as `&hmr &caps_word RALT`, for the behaviors named in `MULTI_PARAM_BEHAVIORS` in `src/keymap_align/align.py`
+- Names the keymap file `#define`s to a binding, such as `XXX` for `&none`
+- Split keyboard layouts with empty positions
+- In-place file modification or separate output
+
+## Installation
+
+```bash
+uv tool install keymap-align
+```
+
+`keymap-align update` installs the newest release.
+
+## Quick Start
+
+```bash
+# Align a keymap in place, using a board that ships with the tool
+keymap-align format -k config/corne.keymap --layout corne42
+
+# Use a layout file of your own, and write to a separate file
+keymap-align format -k config/glove80.keymap -l my_layout.json -o aligned.keymap
+
+# Debug mode: show the layout and each layer's grid without writing
+keymap-align format -k config/piantor.keymap --layout piantor --debug
+```
+
+`keymap-align layouts list` prints the boards that ship with the tool.
+
+## Config File
+
+A `keymap_align.toml` saves passing the layout on every run:
+
+```toml
+layout = "corne42"   # a bundled board name, or a path to a layout JSON file
+indent_size = 4      # spaces before each binding row
+padding = 2          # spaces between columns
+```
+
+- The search starts in the keymap file's directory and walks up to the git root, or to the filesystem root outside a repository. The working directory plays no part.
+- A `layout` value containing `/` or `\`, or ending in `.json`, is a path. A relative path resolves against the config file's directory. Any other value is a bundled board name.
+- `--layout-file` beats `--layout`, and either flag beats the config file.
+- `indent_size` and `padding` are set only here. No flag sets them.
+- A config file that fails to parse prints a warning, and the run continues without it.
+
+The search lets an editor formatter pass nothing but the keymap. For conform.nvim:
+
+```lua
+keymap_align = {
+  command = 'keymap-align',
+  args = { 'format', '-k', '$FILENAME' },
+  stdin = false,
+},
+```
+
+## Layout JSON Format
+
+Layout files define the physical key matrix using `"X"` for key positions and `"-"` for empty spaces:
+
+```json
+{
+  "name": "Corne 42 Layout",
+  "layout": [
+    ["X", "X", "X", "X", "X", "X", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["X", "X", "X", "X", "X", "X", "-", "-", "X", "X", "X", "X", "X", "X"],
+    ["-", "-", "-", "-", "X", "X", "X", "X", "X", "X", "-", "-", "-", "-"]
+  ]
+}
+```
+
+The bundled boards are files in this format in `src/keymap_align/layouts/`. Adding a file there adds a board, named by the file stem.
+
+## How It Works
+
+1. **Parse**: Find each layer node inside the keymap's `keymap { … }` node, and read its `bindings` array
+2. **Structure**: Place each layer's bindings, in order, into the layout's `"X"` cells
+3. **Calculate**: Give each column the width of its widest binding across all layers, plus `padding`
+4. **Rewrite**: Replace the text between each array's `<` and `>` with the aligned rows. Each row is indented `indent_size` spaces, and the closing `>` goes on its own line at the indentation of the line holding `bindings`
+
+Everything outside those arrays is kept byte for byte: comments, blank lines, node names, `display-name`, and every other property, such as `sensor-bindings`. A layer with fewer bindings than the layout has keys gets a blank cell for each one missing.
+
+A run exits 1 and writes nothing when the keymap cannot be rewritten without losing text:
+
+- a layer holds more bindings than the layout has keys;
+- a `bindings` array holds a comment, or a token that does not belong to any binding, such as an undefined macro name before the first `&`;
+- two layer nodes share a name;
+- a `bindings` property holds more than one `< >` array.
+
+## Project Structure
+
+```text
+keymap-align/
+├── src/keymap_align/
+│   ├── align.py            # Parsing, column widths and the in-place rewrite
+│   ├── cli.py              # CLI entry point
+│   ├── config.py           # keymap_align.toml discovery and loading
+│   ├── layout_resolver.py  # Flag and config precedence, bundled board lookup
+│   └── layouts/            # Bundled board layouts, one JSON file each
+└── tests/
+    ├── layouts/            # Test layout files
+    ├── simple_tests/       # Simple test keymaps
+    └── test_keymaps/
+        ├── correct/        # Reference output files, compared byte for byte
+        └── misaligned/     # Test input files
+```
+
+## Development
+
+```bash
+git clone https://github.com/datapointchris/keymap-align
+cd keymap-align
+uv sync --all-groups
+uv run pre-commit install
+
+# Run tests
+uv run pytest
+
+# Code quality
+uv run ruff check src/
+uv run ruff format src/
+uv run mypy src/
+
+# Pre-commit (runs all checks)
+uv run pre-commit run --all-files
+```
+
+## License
+
+MIT License

keymap_align-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+keymap_align/__init__.py,sha256=c3f-b_bT1-IVmIpuLtAZTJXFUdkRaJIn9vPYXrW69Gg,47
+keymap_align/align.py,sha256=k8cv3GyvCBKIRX8EOCco4-8FDDlGwVkLm-0xyS484zE,25425
+keymap_align/cli.py,sha256=vtQ95iVzS-Wu2ri9hQV-Nu2ic1rMZQwhJ24GI2oZ6Mo,5866
+keymap_align/config.py,sha256=9uqP3cRZoAau_2nmDBjc3Wlb5VfJZWEQYPdCfk78gpw,3783
+keymap_align/layout_resolver.py,sha256=Klj7f7OqRxGbNfe_C3kUViSd6QKPbxdElb3flxMUlas,3139
+keymap_align/layouts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keymap_align/layouts/corne42.json,sha256=qpn5nTEHJyGMqGuzu8zbnWX0Ml5b4VX2k_lpjsu9-AA,738
+keymap_align/layouts/glove80.json,sha256=ZSSJ_fVvAvejHiX0c4HXcar-I1TeqzViIPZOLK4eUxU,1333
+keymap_align/layouts/piantor.json,sha256=did8mfnSdICO0eHSwk28BQ1OUsbf-GGTL743NHPbUcU,747
+keymap_align-0.2.0.dist-info/METADATA,sha256=B0MI6ELFtDGfK-qk_QAgtk7tKvlolpl04_9zH9ohPrI,6160
+keymap_align-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+keymap_align-0.2.0.dist-info/entry_points.txt,sha256=Ud0xTigCLDMNiIQhEsmo55GiNMP949a9UjxUlbR6vwQ,54
+keymap_align-0.2.0.dist-info/licenses/LICENSE,sha256=GAtoA41_GNRzmpuNDCm36J0OQXWmAEkUJXwqla22KLo,1068
+keymap_align-0.2.0.dist-info/RECORD,,

keymap_align-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

keymap_align-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+keymap-align = keymap_align.cli:app

keymap_align-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chris Birch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.