jsonx-cli 0.1.0__py3-none-any.whl

jsonx/__init__.py

@@ -0,0 +1,3 @@
+"""jsonx - JSON query and transform CLI"""
+
+__version__ = "0.1.0"

jsonx/cli.py

@@ -0,0 +1,522 @@
+"""jsonx CLI - JSON query and transform tool."""
+
+import json
+import sys
+from typing import Optional
+
+import click
+
+from . import __version__
+from .path import (
+    get_value, set_value, delete_value, flatten, unflatten,
+    keys, merge, diff
+)
+
+
+def load_json(source: Optional[str]) -> dict:
+    """Load JSON from file or stdin."""
+    if source is None or source == '-':
+        data = sys.stdin.read()
+    else:
+        with open(source, 'r') as f:
+            data = f.read()
+    
+    return json.loads(data)
+
+
+def output(data, json_output: bool = False, pretty: bool = True):
+    """Output data appropriately."""
+    if isinstance(data, (dict, list)):
+        if pretty:
+            click.echo(json.dumps(data, indent=2, ensure_ascii=False))
+        else:
+            click.echo(json.dumps(data, ensure_ascii=False))
+    elif isinstance(data, bool):
+        # JSON booleans are lowercase
+        click.echo(json.dumps(data))
+    elif data is None:
+        click.echo("null")
+    elif json_output:
+        click.echo(json.dumps(data, ensure_ascii=False))
+    else:
+        click.echo(data)
+
+
+@click.group()
+@click.version_option(version=__version__)
+def main():
+    """JSON query and transform CLI - simpler than jq.
+    
+    Examples:
+    
+        # Get nested value
+        jsonx get .users[0].name data.json
+        
+        # Query from stdin
+        cat data.json | jsonx get .config.debug
+        
+        # Set value and output
+        jsonx set .config.debug true data.json
+        
+        # List keys
+        jsonx keys data.json
+        
+        # Flatten nested structure
+        jsonx flatten data.json
+    """
+    pass
+
+
+@main.command()
+@click.argument('path', default='.')
+@click.argument('source', required=False)
+@click.option('--json', 'json_out', is_flag=True, help='Force JSON output')
+@click.option('--raw', '-r', is_flag=True, help='Raw output (no quotes for strings)')
+def get(path: str, source: Optional[str], json_out: bool, raw: bool):
+    """Get value at path.
+    
+    PATH uses dot notation:
+    
+        .key           - object key
+        .key.nested    - nested key
+        [0]            - array index
+        [*]            - all array items
+        [0:3]          - array slice
+    
+    Examples:
+    
+        jsonx get .name data.json
+        jsonx get .users[0].email data.json
+        jsonx get .users[*].name data.json
+        cat data.json | jsonx get .config
+    """
+    try:
+        data = load_json(source)
+        result = get_value(data, path)
+        
+        if raw and isinstance(result, str):
+            click.echo(result)
+        else:
+            output(result, json_out)
+    
+    except (KeyError, IndexError, TypeError) as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        click.echo(f"Invalid JSON: {e}", err=True)
+        sys.exit(1)
+    except FileNotFoundError:
+        click.echo(f"File not found: {source}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('path')
+@click.argument('value')
+@click.argument('source', required=False)
+@click.option('--in-place', '-i', is_flag=True, help='Modify file in place')
+@click.option('--output', '-o', 'outfile', help='Write to file')
+@click.option('--compact', '-c', is_flag=True, help='Compact output')
+def set(path: str, value: str, source: Optional[str], in_place: bool, outfile: Optional[str], compact: bool):
+    """Set value at path.
+    
+    VALUE is parsed as JSON. Use quotes for strings.
+    
+    Examples:
+    
+        jsonx set .debug true data.json
+        jsonx set .name '"Alice"' data.json
+        jsonx set .tags '["a","b"]' data.json
+        jsonx set .config.timeout 30 data.json -i
+    """
+    try:
+        data = load_json(source)
+        
+        # Parse value as JSON
+        try:
+            parsed_value = json.loads(value)
+        except json.JSONDecodeError:
+            # Treat as string if not valid JSON
+            parsed_value = value
+        
+        result = set_value(data, path, parsed_value)
+        
+        if in_place and source and source != '-':
+            with open(source, 'w') as f:
+                json.dump(result, f, indent=2 if not compact else None, ensure_ascii=False)
+                f.write('\n')
+        elif outfile:
+            with open(outfile, 'w') as f:
+                json.dump(result, f, indent=2 if not compact else None, ensure_ascii=False)
+                f.write('\n')
+        else:
+            output(result, pretty=not compact)
+    
+    except (KeyError, TypeError) as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        click.echo(f"Invalid JSON: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command('del')
+@click.argument('path')
+@click.argument('source', required=False)
+@click.option('--in-place', '-i', is_flag=True, help='Modify file in place')
+@click.option('--output', '-o', 'outfile', help='Write to file')
+def delete(path: str, source: Optional[str], in_place: bool, outfile: Optional[str]):
+    """Delete value at path.
+    
+    Examples:
+    
+        jsonx del .temp data.json
+        jsonx del .users[0] data.json -i
+    """
+    try:
+        data = load_json(source)
+        result = delete_value(data, path)
+        
+        if in_place and source and source != '-':
+            with open(source, 'w') as f:
+                json.dump(result, f, indent=2, ensure_ascii=False)
+                f.write('\n')
+        elif outfile:
+            with open(outfile, 'w') as f:
+                json.dump(result, f, indent=2, ensure_ascii=False)
+                f.write('\n')
+        else:
+            output(result)
+    
+    except (KeyError, IndexError, TypeError) as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('source', required=False)
+@click.option('--recursive', '-r', is_flag=True, help='Show all nested keys with paths')
+@click.option('--json', 'json_out', is_flag=True, help='JSON output')
+def keys(source: Optional[str], recursive: bool, json_out: bool):
+    """List keys in JSON object.
+    
+    Examples:
+    
+        jsonx keys data.json
+        jsonx keys data.json -r   # All nested keys
+    """
+    try:
+        from .path import keys as get_keys
+        
+        data = load_json(source)
+        result = get_keys(data, recursive=recursive)
+        
+        if json_out:
+            click.echo(json.dumps(result, indent=2))
+        else:
+            for key in result:
+                click.echo(key)
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('source', required=False)
+@click.option('--sep', default='.', help='Key separator')
+def flatten(source: Optional[str], sep: str):
+    """Flatten nested JSON to dot-notation keys.
+    
+    Examples:
+    
+        jsonx flatten data.json
+        # {"users[0].name": "Alice", "config.debug": true}
+    """
+    try:
+        from .path import flatten as do_flatten
+        
+        data = load_json(source)
+        result = do_flatten(data, sep=sep)
+        output(result)
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('source', required=False)
+@click.option('--sep', default='.', help='Key separator')
+def unflatten(source: Optional[str], sep: str):
+    """Unflatten dot-notation keys to nested structure.
+    
+    Examples:
+    
+        echo '{"user.name": "Alice"}' | jsonx unflatten
+        # {"user": {"name": "Alice"}}
+    """
+    try:
+        from .path import unflatten as do_unflatten
+        
+        data = load_json(source)
+        result = do_unflatten(data, sep=sep)
+        output(result)
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('files', nargs=-1, required=True)
+@click.option('--deep/--shallow', default=True, help='Deep merge nested objects')
+def merge(files: tuple, deep: bool):
+    """Merge multiple JSON files.
+    
+    Later files override earlier ones.
+    
+    Examples:
+    
+        jsonx merge base.json override.json
+        jsonx merge a.json b.json c.json
+    """
+    try:
+        from .path import merge as do_merge
+        
+        if len(files) < 2:
+            click.echo("Need at least 2 files to merge", err=True)
+            sys.exit(1)
+        
+        result = load_json(files[0])
+        for f in files[1:]:
+            overlay = load_json(f)
+            result = do_merge(result, overlay, deep=deep)
+        
+        output(result)
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('file1')
+@click.argument('file2')
+@click.option('--json', 'json_out', is_flag=True, help='JSON output')
+def diff(file1: str, file2: str, json_out: bool):
+    """Show differences between two JSON files.
+    
+    Examples:
+    
+        jsonx diff old.json new.json
+    """
+    try:
+        from .path import diff as do_diff
+        
+        a = load_json(file1)
+        b = load_json(file2)
+        differences = do_diff(a, b)
+        
+        if not differences:
+            click.echo("No differences")
+            return
+        
+        if json_out:
+            click.echo(json.dumps(differences, indent=2))
+        else:
+            for d in differences:
+                path = d['path']
+                dtype = d['type']
+                
+                if dtype == 'added':
+                    click.echo(click.style(f"+ {path}: {json.dumps(d['value'])}", fg='green'))
+                elif dtype == 'removed':
+                    click.echo(click.style(f"- {path}: {json.dumps(d['value'])}", fg='red'))
+                elif dtype == 'changed':
+                    click.echo(click.style(f"~ {path}: {json.dumps(d['old'])} → {json.dumps(d['new'])}", fg='yellow'))
+                elif dtype == 'type_change':
+                    click.echo(click.style(f"! {path}: type changed {json.dumps(d['old'])} → {json.dumps(d['new'])}", fg='magenta'))
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('source', required=False)
+@click.option('--indent', '-i', default=2, type=int, help='Indentation level')
+@click.option('--sort-keys', '-s', is_flag=True, help='Sort object keys')
+def format(source: Optional[str], indent: int, sort_keys: bool):
+    """Pretty print JSON.
+    
+    Examples:
+    
+        jsonx format data.json
+        cat data.json | jsonx format --indent 4
+    """
+    try:
+        data = load_json(source)
+        click.echo(json.dumps(data, indent=indent, sort_keys=sort_keys, ensure_ascii=False))
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('source', required=False)
+def minify(source: Optional[str]):
+    """Minify JSON (compact format).
+    
+    Examples:
+    
+        jsonx minify data.json
+        jsonx minify data.json > data.min.json
+    """
+    try:
+        data = load_json(source)
+        click.echo(json.dumps(data, separators=(',', ':'), ensure_ascii=False))
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('source', required=False)
+@click.argument('schema')
+def validate(source: Optional[str], schema: str):
+    """Validate JSON against a JSON Schema.
+    
+    Requires: pip install jsonx-cli[schema]
+    
+    Examples:
+    
+        jsonx validate data.json schema.json
+    """
+    try:
+        import jsonschema
+    except ImportError:
+        click.echo("jsonschema not installed. Run: pip install jsonx-cli[schema]", err=True)
+        sys.exit(1)
+    
+    try:
+        data = load_json(source)
+        schema_data = load_json(schema)
+        
+        jsonschema.validate(data, schema_data)
+        click.echo(click.style("✓ Valid", fg='green'))
+    
+    except jsonschema.ValidationError as e:
+        click.echo(click.style(f"✗ Invalid: {e.message}", fg='red'), err=True)
+        click.echo(f"  Path: {'.'.join(str(p) for p in e.absolute_path)}", err=True)
+        sys.exit(1)
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('source', required=False)
+def type(source: Optional[str]):
+    """Show the type of JSON value.
+    
+    Examples:
+    
+        echo '[]' | jsonx type     # array
+        echo '{}' | jsonx type     # object
+        echo '42' | jsonx type     # number
+    """
+    try:
+        data = load_json(source)
+        
+        if isinstance(data, dict):
+            click.echo("object")
+        elif isinstance(data, list):
+            click.echo("array")
+        elif isinstance(data, str):
+            click.echo("string")
+        elif isinstance(data, bool):
+            click.echo("boolean")
+        elif isinstance(data, int):
+            click.echo("integer")
+        elif isinstance(data, float):
+            click.echo("number")
+        elif data is None:
+            click.echo("null")
+        else:
+            click.echo("unknown")
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('source', required=False)
+def count(source: Optional[str]):
+    """Count items in array or keys in object.
+    
+    Examples:
+    
+        jsonx count data.json           # Count top-level
+        jsonx get .users data.json | jsonx count  # Count users
+    """
+    try:
+        data = load_json(source)
+        
+        if isinstance(data, (list, dict)):
+            click.echo(len(data))
+        else:
+            click.echo("1")
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command('each')
+@click.argument('source', required=False)
+@click.option('--path', '-p', default='.', help='Path to array')
+@click.option('--template', '-t', help='Output template (use {.key} for values)')
+def each(source: Optional[str], path: str, template: Optional[str]):
+    """Iterate over array items.
+    
+    Examples:
+    
+        jsonx each data.json -p .users -t '{.name}: {.email}'
+        jsonx get .items data.json | jsonx each -t '{.id}'
+    """
+    try:
+        data = load_json(source)
+        items = get_value(data, path)
+        
+        if not isinstance(items, list):
+            click.echo("Path must point to an array", err=True)
+            sys.exit(1)
+        
+        for item in items:
+            if template:
+                # Simple template expansion
+                result = template
+                # Find all {.path} patterns
+                import re
+                for match in re.finditer(r'\{(\.[^}]+)\}', template):
+                    item_path = match.group(1)
+                    try:
+                        val = get_value(item, item_path)
+                        result = result.replace(match.group(0), str(val))
+                    except (KeyError, TypeError):
+                        result = result.replace(match.group(0), '')
+                click.echo(result)
+            else:
+                click.echo(json.dumps(item, ensure_ascii=False))
+    
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

jsonx/path.py

@@ -0,0 +1,445 @@
+"""JSON path query engine with simple dot notation."""
+
+import re
+from typing import Any, List, Tuple, Union
+
+# Path segment patterns
+ARRAY_INDEX = re.compile(r'\[(-?\d+)\]')
+ARRAY_SLICE = re.compile(r'\[(\d*):(\d*)\]')
+ARRAY_WILDCARD = re.compile(r'\[\*\]')
+
+
+def parse_path(path: str) -> List[Union[str, int, Tuple[int, int], None]]:
+    """
+    Parse a dot-notation path into segments.
+    
+    Examples:
+        ".users[0].name" -> ["users", 0, "name"]
+        ".data[*].id" -> ["data", None, "id"]  (None = wildcard)
+        ".items[1:3]" -> ["items", (1, 3)]
+    """
+    if not path or path == '.':
+        return []
+    
+    # Remove leading dot
+    if path.startswith('.'):
+        path = path[1:]
+    
+    segments = []
+    current = ""
+    i = 0
+    
+    while i < len(path):
+        char = path[i]
+        
+        if char == '.':
+            if current:
+                segments.append(current)
+                current = ""
+            i += 1
+        elif char == '[':
+            if current:
+                segments.append(current)
+                current = ""
+            
+            # Find matching bracket
+            end = path.find(']', i)
+            if end == -1:
+                raise ValueError(f"Unclosed bracket in path: {path}")
+            
+            bracket_content = path[i:end+1]
+            
+            # Check for wildcard
+            if bracket_content == '[*]':
+                segments.append(None)  # None represents wildcard
+            # Check for slice
+            elif ':' in bracket_content:
+                match = ARRAY_SLICE.match(bracket_content)
+                if match:
+                    start = int(match.group(1)) if match.group(1) else 0
+                    end_idx = int(match.group(2)) if match.group(2) else None
+                    segments.append((start, end_idx))
+            # Check for index
+            else:
+                match = ARRAY_INDEX.match(bracket_content)
+                if match:
+                    segments.append(int(match.group(1)))
+                else:
+                    # Treat as string key (for object keys with special chars)
+                    key = bracket_content[1:-1].strip('"\'')
+                    segments.append(key)
+            
+            i = end + 1
+        else:
+            current += char
+            i += 1
+    
+    if current:
+        segments.append(current)
+    
+    return segments
+
+
+def get_value(data: Any, path: str) -> Any:
+    """
+    Get value at path from JSON data.
+    
+    Args:
+        data: JSON data (dict, list, or primitive)
+        path: Dot-notation path (e.g., ".users[0].name")
+    
+    Returns:
+        Value at path, or list of values for wildcards
+    
+    Raises:
+        KeyError: If path doesn't exist
+        IndexError: If array index out of bounds
+    """
+    if not path or path == '.':
+        return data
+    
+    segments = parse_path(path)
+    return _get_by_segments(data, segments)
+
+
+def _get_by_segments(data: Any, segments: List) -> Any:
+    """Navigate data using parsed segments."""
+    if not segments:
+        return data
+    
+    current = data
+    remaining_segments = list(segments)
+    
+    while remaining_segments:
+        segment = remaining_segments.pop(0)
+        
+        if segment is None:
+            # Wildcard - apply remaining path to each element
+            if not isinstance(current, list):
+                raise TypeError(f"Wildcard [*] requires array, got {type(current).__name__}")
+            
+            if not remaining_segments:
+                return current
+            
+            return [_get_by_segments(item, remaining_segments) for item in current]
+        
+        elif isinstance(segment, tuple):
+            # Slice
+            if not isinstance(current, list):
+                raise TypeError(f"Slice requires array, got {type(current).__name__}")
+            
+            start, end = segment
+            sliced = current[start:end]
+            
+            if not remaining_segments:
+                return sliced
+            
+            return [_get_by_segments(item, remaining_segments) for item in sliced]
+        
+        elif isinstance(segment, int):
+            # Array index
+            if isinstance(current, list):
+                current = current[segment]
+            elif isinstance(current, dict):
+                # Some dicts use int keys (rare but possible)
+                current = current[segment]
+            else:
+                raise TypeError(f"Cannot index {type(current).__name__}")
+        
+        else:
+            # String key
+            if isinstance(current, dict):
+                if segment not in current:
+                    raise KeyError(f"Key not found: {segment}")
+                current = current[segment]
+            elif isinstance(current, list):
+                # Maybe trying to get key from objects in list?
+                raise TypeError(f"Cannot get key '{segment}' from array. Use [*].{segment} for all items.")
+            else:
+                raise TypeError(f"Cannot get key from {type(current).__name__}")
+    
+    return current
+
+
+def set_value(data: Any, path: str, value: Any) -> Any:
+    """
+    Set value at path in JSON data (returns modified copy).
+    
+    Args:
+        data: JSON data
+        path: Dot-notation path
+        value: Value to set
+    
+    Returns:
+        Modified copy of data
+    """
+    if not path or path == '.':
+        return value
+    
+    segments = parse_path(path)
+    return _set_by_segments(data, segments, value)
+
+
+def _set_by_segments(data: Any, segments: List, value: Any) -> Any:
+    """Set value using parsed segments."""
+    if not segments:
+        return value
+    
+    segment = segments[0]
+    remaining = segments[1:]
+    
+    if isinstance(segment, int):
+        # Array index
+        if data is None:
+            data = []
+        if not isinstance(data, list):
+            raise TypeError(f"Cannot index {type(data).__name__}")
+        
+        # Extend list if needed
+        while len(data) <= segment:
+            data.append(None)
+        
+        result = list(data)
+        result[segment] = _set_by_segments(result[segment], remaining, value)
+        return result
+    
+    elif isinstance(segment, str):
+        # Object key
+        if data is None:
+            data = {}
+        if not isinstance(data, dict):
+            raise TypeError(f"Cannot set key on {type(data).__name__}")
+        
+        result = dict(data)
+        result[segment] = _set_by_segments(result.get(segment), remaining, value)
+        return result
+    
+    else:
+        raise ValueError(f"Cannot set value with wildcard or slice in path")
+
+
+def delete_value(data: Any, path: str) -> Any:
+    """
+    Delete value at path (returns modified copy).
+    
+    Args:
+        data: JSON data
+        path: Dot-notation path
+    
+    Returns:
+        Modified copy with value removed
+    """
+    if not path or path == '.':
+        return None
+    
+    segments = parse_path(path)
+    return _delete_by_segments(data, segments)
+
+
+def _delete_by_segments(data: Any, segments: List) -> Any:
+    """Delete value using parsed segments."""
+    if not segments:
+        return None
+    
+    if len(segments) == 1:
+        segment = segments[0]
+        if isinstance(segment, int) and isinstance(data, list):
+            result = list(data)
+            del result[segment]
+            return result
+        elif isinstance(segment, str) and isinstance(data, dict):
+            result = dict(data)
+            del result[segment]
+            return result
+        else:
+            raise TypeError(f"Cannot delete from {type(data).__name__}")
+    
+    segment = segments[0]
+    remaining = segments[1:]
+    
+    if isinstance(segment, int) and isinstance(data, list):
+        result = list(data)
+        result[segment] = _delete_by_segments(result[segment], remaining)
+        return result
+    elif isinstance(segment, str) and isinstance(data, dict):
+        result = dict(data)
+        result[segment] = _delete_by_segments(result.get(segment), remaining)
+        return result
+    else:
+        raise TypeError(f"Cannot navigate {type(data).__name__}")
+
+
+def flatten(data: Any, prefix: str = "", sep: str = ".") -> dict:
+    """
+    Flatten nested JSON to dot-notation keys.
+    
+    Args:
+        data: JSON data
+        prefix: Current path prefix
+        sep: Separator (default ".")
+    
+    Returns:
+        Flat dict with dot-notation keys
+    """
+    result = {}
+    
+    if isinstance(data, dict):
+        for key, value in data.items():
+            new_key = f"{prefix}{sep}{key}" if prefix else key
+            if isinstance(value, (dict, list)):
+                result.update(flatten(value, new_key, sep))
+            else:
+                result[new_key] = value
+    
+    elif isinstance(data, list):
+        for i, item in enumerate(data):
+            new_key = f"{prefix}[{i}]"
+            if isinstance(item, (dict, list)):
+                result.update(flatten(item, new_key, sep))
+            else:
+                result[new_key] = item
+    
+    else:
+        result[prefix] = data
+    
+    return result
+
+
+def unflatten(data: dict, sep: str = ".") -> Any:
+    """
+    Unflatten dot-notation keys back to nested structure.
+    
+    Args:
+        data: Flat dict with dot-notation keys
+        sep: Separator (default ".")
+    
+    Returns:
+        Nested JSON structure
+    """
+    result = {}
+    
+    for key, value in data.items():
+        parts = key.replace('[', sep + '[').split(sep)
+        current = result
+        
+        for i, part in enumerate(parts[:-1]):
+            # Handle array indices
+            if part.startswith('[') and part.endswith(']'):
+                idx = int(part[1:-1])
+                while len(current) <= idx:
+                    current.append(None)
+                if current[idx] is None:
+                    # Peek ahead to determine type
+                    next_part = parts[i + 1]
+                    current[idx] = [] if next_part.startswith('[') else {}
+                current = current[idx]
+            else:
+                if part not in current:
+                    # Peek ahead to determine type
+                    next_part = parts[i + 1]
+                    current[part] = [] if next_part.startswith('[') else {}
+                current = current[part]
+        
+        # Set final value
+        last = parts[-1]
+        if last.startswith('[') and last.endswith(']'):
+            idx = int(last[1:-1])
+            while len(current) <= idx:
+                current.append(None)
+            current[idx] = value
+        else:
+            current[last] = value
+    
+    return result
+
+
+def keys(data: Any, recursive: bool = False) -> List[str]:
+    """
+    Get all keys from JSON data.
+    
+    Args:
+        data: JSON data
+        recursive: If True, return all nested keys with paths
+    
+    Returns:
+        List of keys (or paths if recursive)
+    """
+    if not isinstance(data, dict):
+        return []
+    
+    if not recursive:
+        return list(data.keys())
+    
+    return list(flatten(data).keys())
+
+
+def merge(base: Any, overlay: Any, deep: bool = True) -> Any:
+    """
+    Merge two JSON structures.
+    
+    Args:
+        base: Base data
+        overlay: Data to merge on top
+        deep: If True, merge nested dicts recursively
+    
+    Returns:
+        Merged data
+    """
+    if not isinstance(base, dict) or not isinstance(overlay, dict):
+        return overlay
+    
+    result = dict(base)
+    
+    for key, value in overlay.items():
+        if deep and key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = merge(result[key], value, deep)
+        else:
+            result[key] = value
+    
+    return result
+
+
+def diff(a: Any, b: Any, path: str = "") -> List[dict]:
+    """
+    Find differences between two JSON structures.
+    
+    Args:
+        a: First JSON data
+        b: Second JSON data
+        path: Current path (internal)
+    
+    Returns:
+        List of difference objects with path, type, and values
+    """
+    differences = []
+    
+    if type(a) != type(b):
+        return [{"path": path or ".", "type": "type_change", "old": a, "new": b}]
+    
+    if isinstance(a, dict):
+        all_keys = set(a.keys()) | set(b.keys())
+        for key in all_keys:
+            new_path = f"{path}.{key}" if path else key
+            if key not in a:
+                differences.append({"path": new_path, "type": "added", "value": b[key]})
+            elif key not in b:
+                differences.append({"path": new_path, "type": "removed", "value": a[key]})
+            else:
+                differences.extend(diff(a[key], b[key], new_path))
+    
+    elif isinstance(a, list):
+        max_len = max(len(a), len(b))
+        for i in range(max_len):
+            new_path = f"{path}[{i}]"
+            if i >= len(a):
+                differences.append({"path": new_path, "type": "added", "value": b[i]})
+            elif i >= len(b):
+                differences.append({"path": new_path, "type": "removed", "value": a[i]})
+            else:
+                differences.extend(diff(a[i], b[i], new_path))
+    
+    else:
+        if a != b:
+            differences.append({"path": path or ".", "type": "changed", "old": a, "new": b})
+    
+    return differences

jsonx_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: jsonx-cli
+Version: 0.1.0
+Summary: JSON query and transform CLI - simpler than jq
+Project-URL: Homepage, https://github.com/marcusbuildsthings-droid/jsonx
+Project-URL: Repository, https://github.com/marcusbuildsthings-droid/jsonx
+Project-URL: Issues, https://github.com/marcusbuildsthings-droid/jsonx/issues
+Author-email: Marcus <marcus.builds.things@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: automation,cli,jq,json,query,transform
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Requires-Dist: click>=8.0.0
+Provides-Extra: schema
+Requires-Dist: jsonschema>=4.0.0; extra == 'schema'
+Description-Content-Type: text/markdown
+
+# jsonx
+
+JSON query and transform CLI — simpler than jq.
+
+[![PyPI version](https://badge.fury.io/py/jsonx-cli.svg)](https://pypi.org/project/jsonx-cli/)
+
+## Installation
+
+```bash
+pip install jsonx-cli
+```
+
+For JSON Schema validation:
+```bash
+pip install jsonx-cli[schema]
+```
+
+## Quick Start
+
+```bash
+# Get a nested value
+jsonx get .users[0].name data.json
+
+# From stdin
+cat data.json | jsonx get .config.debug
+
+# Set a value
+jsonx set .config.debug true data.json
+
+# List all keys
+jsonx keys data.json
+
+# Pretty print
+jsonx format data.json
+```
+
+## Path Syntax
+
+jsonx uses simple dot notation:
+
+| Pattern | Meaning |
+|---------|---------|
+| `.key` | Object property |
+| `.nested.key` | Nested property |
+| `[0]` | Array index |
+| `[-1]` | Last array item |
+| `[*]` | All array items |
+| `[0:3]` | Array slice |
+
+Examples:
+```bash
+jsonx get .name data.json           # Get "name" property
+jsonx get .users[0] data.json       # First user
+jsonx get .users[-1] data.json      # Last user
+jsonx get .users[*].email data.json # All user emails
+jsonx get .items[0:5] data.json     # First 5 items
+```
+
+## Commands
+
+### get - Extract values
+
+```bash
+jsonx get .path [file]          # Extract value at path
+jsonx get .path file --raw      # Raw output (no quotes)
+jsonx get .path file --json     # Force JSON output
+```
+
+### set - Modify values
+
+```bash
+jsonx set .path value [file]    # Set and output
+jsonx set .path value file -i   # Modify in place
+jsonx set .path value file -o out.json  # Write to file
+```
+
+Value is parsed as JSON:
+```bash
+jsonx set .debug true data.json           # boolean
+jsonx set .count 42 data.json             # number
+jsonx set .name '"Alice"' data.json       # string (note quotes)
+jsonx set .tags '["a","b"]' data.json     # array
+```
+
+### del - Delete values
+
+```bash
+jsonx del .path [file]          # Delete and output
+jsonx del .path file -i         # Delete in place
+```
+
+### keys - List keys
+
+```bash
+jsonx keys [file]               # Top-level keys
+jsonx keys file -r              # All keys recursively
+```
+
+### flatten / unflatten - Structure transformation
+
+```bash
+# Flatten nested structure
+jsonx flatten data.json
+# {"users[0].name": "Alice", "config.debug": true}
+
+# Unflatten back
+echo '{"user.name": "Alice"}' | jsonx unflatten
+# {"user": {"name": "Alice"}}
+```
+
+### merge - Combine files
+
+```bash
+jsonx merge base.json override.json     # Deep merge
+jsonx merge a.json b.json --shallow     # Shallow merge
+```
+
+### diff - Compare files
+
+```bash
+jsonx diff old.json new.json
+# + config.newKey: "value"      (green - added)
+# - config.removed: true        (red - removed)  
+# ~ config.changed: 1 → 2       (yellow - changed)
+```
+
+### format / minify - Pretty print
+
+```bash
+jsonx format data.json              # Pretty print
+jsonx format data.json -i 4         # 4-space indent
+jsonx minify data.json              # Compact
+```
+
+### validate - JSON Schema
+
+```bash
+jsonx validate data.json schema.json
+# ✓ Valid
+# or
+# ✗ Invalid: 'email' is required
+```
+
+### type - Show value type
+
+```bash
+echo '[]' | jsonx type        # array
+echo '{}' | jsonx type        # object
+echo '42' | jsonx type        # integer
+```
+
+### count - Count items
+
+```bash
+jsonx count data.json                     # Top-level count
+jsonx get .users data.json | jsonx count  # Count array items
+```
+
+### each - Iterate arrays
+
+```bash
+# Output each item as JSON
+jsonx each data.json -p .users
+
+# With template
+jsonx each data.json -p .users -t '{.name}: {.email}'
+```
+
+## Piping
+
+jsonx works great in pipelines:
+
+```bash
+# Extract, transform, merge
+cat config.json | jsonx get .database | jsonx set .host '"prod.db"'
+
+# Count users
+jsonx get .users data.json | jsonx count
+
+# Extract all emails
+jsonx get .users[*].email data.json
+
+# Filter and format
+curl api/data | jsonx get .results | jsonx format
+```
+
+## For AI Agents
+
+See [SKILL.md](SKILL.md) for agent-optimized documentation.
+
+## Exit Codes
+
+- `0` - Success
+- `1` - Error (invalid JSON, path not found, etc.)
+
+## License
+
+MIT

jsonx_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+jsonx/__init__.py,sha256=spRgGeMbGVHl4Pq-gtFd-OIC1PKaS7XPm46feruLj8I,66
+jsonx/cli.py,sha256=PsUrtJYyC0yO2mIc0qXwNyd4Rj_NeWwNSGu48fN3wBU,15310
+jsonx/path.py,sha256=YKRGfDUXkTBjqPDO90lo-U9_kY98ZRwcp9mwoIjFbzo,13290
+jsonx_cli-0.1.0.dist-info/METADATA,sha256=jK0-SruqZ0g4PwQwyl70ugu6Wf50OmSsEEV5k_JpSho,5283
+jsonx_cli-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+jsonx_cli-0.1.0.dist-info/entry_points.txt,sha256=joRB7Mfd6w4Xz2T4ZlJCf0e0hRcZ9TtoY_SNih0fzCg,41
+jsonx_cli-0.1.0.dist-info/licenses/LICENSE,sha256=9tNBpWq8KGbuJqmeComp40OiNnbvpvsKn1YP26PUtck,1063
+jsonx_cli-0.1.0.dist-info/RECORD,,

jsonx_cli-0.1.0.dist-info/WHEEL

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

jsonx_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jsonx = jsonx.cli:main

jsonx_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marcus
+
+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.