diff-cli 0.1.0__tar.gz

diff_cli-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/

diff_cli-0.1.0/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.

diff_cli-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: diff-cli
+Version: 0.1.0
+Summary: File and text differ with multiple output formats
+Project-URL: Homepage, https://github.com/marcusbuildsthings-droid/diff-cli
+Project-URL: Repository, https://github.com/marcusbuildsthings-droid/diff-cli
+Author-email: Marcus <marcus.builds.things@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,compare,diff,side-by-side,text,unified
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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 :: Text Processing :: General
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Description-Content-Type: text/markdown
+
+# diff-cli
+
+File and text differ with multiple output formats.
+
+## Install
+
+```bash
+pip install diff-cli
+```
+
+## Usage
+
+```bash
+# Compare files
+diff-cli files file1.txt file2.txt
+
+# Compare text strings
+diff-cli text "hello world" "hello there"
+
+# Compare directories
+diff-cli dirs dir1/ dir2/
+
+# Output formats
+diff-cli files a.txt b.txt --unified        # Default
+diff-cli files a.txt b.txt --side-by-side    # Two-column
+diff-cli files a.txt b.txt --context         # Context format
+diff-cli files a.txt b.txt --minimal         # Changes only
+diff-cli files a.txt b.txt --json            # JSON for automation
+
+# Options
+diff-cli files a.txt b.txt -n 5             # 5 context lines
+diff-cli files a.txt b.txt --ignore-whitespace
+diff-cli files a.txt b.txt --ignore-case
+diff-cli files a.txt b.txt --ignore-blank-lines
+
+# Watch mode
+diff-cli watch file1.txt file2.txt
+```
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Files are identical |
+| 1 | Files differ |
+| 2 | Error (file not found, etc.) |
+
+## License
+
+MIT

diff_cli-0.1.0/README.md

@@ -0,0 +1,50 @@
+# diff-cli
+
+File and text differ with multiple output formats.
+
+## Install
+
+```bash
+pip install diff-cli
+```
+
+## Usage
+
+```bash
+# Compare files
+diff-cli files file1.txt file2.txt
+
+# Compare text strings
+diff-cli text "hello world" "hello there"
+
+# Compare directories
+diff-cli dirs dir1/ dir2/
+
+# Output formats
+diff-cli files a.txt b.txt --unified        # Default
+diff-cli files a.txt b.txt --side-by-side    # Two-column
+diff-cli files a.txt b.txt --context         # Context format
+diff-cli files a.txt b.txt --minimal         # Changes only
+diff-cli files a.txt b.txt --json            # JSON for automation
+
+# Options
+diff-cli files a.txt b.txt -n 5             # 5 context lines
+diff-cli files a.txt b.txt --ignore-whitespace
+diff-cli files a.txt b.txt --ignore-case
+diff-cli files a.txt b.txt --ignore-blank-lines
+
+# Watch mode
+diff-cli watch file1.txt file2.txt
+```
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Files are identical |
+| 1 | Files differ |
+| 2 | Error (file not found, etc.) |
+
+## License
+
+MIT

diff_cli-0.1.0/SKILL.md

@@ -0,0 +1,262 @@
+# diff-cli - Agent Skill
+
+File and text differ with multiple output formats. Compare files, text strings, and directories with various diff formats and ignore options.
+
+## Quick Command Reference
+
+| Command | Purpose | Key Options |
+|---------|---------|-------------|
+| `diff-cli files <file1> <file2>` | Compare two files | `--format`, `--ignore-*`, `--json` |
+| `diff-cli text "<text1>" "<text2>"` | Compare text strings | `--format`, `--ignore-*`, `--json` |
+| `diff-cli dirs <dir1> <dir2>` | Compare directories | `--recursive`, `--json` |
+| `diff-cli watch <file1> <file2>` | Monitor files for changes | `--interval`, `--format` |
+
+## Command Details
+
+### File Comparison
+```bash
+# Basic comparison with different formats
+diff-cli files old.txt new.txt                    # Unified diff (default)
+diff-cli files old.txt new.txt --format side-by-side
+diff-cli files old.txt new.txt --format context
+diff-cli files old.txt new.txt --format minimal
+
+# Ignore options
+diff-cli files file1.txt file2.txt --ignore-whitespace
+diff-cli files FILE1.txt file2.txt --ignore-case
+diff-cli files log1.txt log2.txt --ignore-blank-lines
+
+# JSON output
+diff-cli files config.json config.json.bak --json
+```
+
+### Text String Comparison
+```bash
+# Direct text comparison
+diff-cli text "hello world" "hello universe"
+diff-cli text "line1\nline2" "line1\nmodified" --format unified
+diff-cli text "TEXT" "text" --ignore-case --json
+```
+
+### Directory Comparison
+```bash
+# Compare directory contents
+diff-cli dirs project/ backup/
+diff-cli dirs src/ dist/ --json
+diff-cli dirs folder1/ folder2/ --recursive
+```
+
+### Watch Mode
+```bash
+# Monitor files for changes
+diff-cli watch config.ini config.ini.tmp
+diff-cli watch log.txt rotated.log --interval 0.5 --format minimal
+```
+
+## Exit Codes
+
+- **0**: Files/texts are identical
+- **1**: Files/texts are different
+- **2**: Error occurred (file not found, binary file, permission denied)
+
+Always check exit codes when using in scripts:
+```bash
+if diff-cli files file1.txt file2.txt --format minimal; then
+    echo "Files are identical"
+else
+    echo "Files differ (exit code: $?)"
+fi
+```
+
+## JSON Output Schemas
+
+### File/Text Comparison (`--json`)
+```json
+{
+  "files": ["file1.txt", "file2.txt"],          // Input files
+  "identical": false,                            // Boolean comparison result
+  "format": "unified",                           // Format used
+  "diff": [                                      // Diff lines (if not minimal)
+    "--- file1.txt",
+    "+++ file2.txt", 
+    "@@ -1,1 +1,1 @@",
+    "-old line",
+    "+new line"
+  ]
+}
+```
+
+### Minimal Format (`--format minimal --json`)
+```json
+{
+  "files": ["file1.txt", "file2.txt"],
+  "identical": false,
+  "format": "minimal",
+  "changes": 2,                                  // Total changes
+  "additions": 1,                                // Lines added
+  "deletions": 1,                                // Lines removed
+  "total_lines_1": 10,                          // Lines in file1
+  "total_lines_2": 10                           // Lines in file2
+}
+```
+
+### Directory Comparison (`--json`)
+```json
+{
+  "total_files": 15,
+  "only_in_first": ["old_file.txt"],            // Files only in dir1
+  "only_in_second": ["new_file.txt"],           // Files only in dir2  
+  "different": ["config.json", "readme.md"],    // Files that differ
+  "identical": ["license.txt"],                 // Identical files
+  "summary": {
+    "only_in_first": 1,
+    "only_in_second": 1,
+    "different": 2,
+    "identical": 1
+  }
+}
+```
+
+## Common Automation Patterns
+
+### Check if files are identical
+```bash
+# Simple check
+diff-cli files file1.txt file2.txt --format minimal >/dev/null
+identical=$?
+
+# With details
+result=$(diff-cli files file1.txt file2.txt --format minimal --json)
+identical=$(echo "$result" | jq -r '.identical')
+```
+
+### Get change statistics
+```bash
+# Count changes
+stats=$(diff-cli files old.txt new.txt --format minimal --json)
+changes=$(echo "$stats" | jq -r '.changes')
+additions=$(echo "$stats" | jq -r '.additions')
+deletions=$(echo "$stats" | jq -r '.deletions')
+
+echo "Changes: $changes (+$additions -$deletions)"
+```
+
+### Directory sync validation
+```bash
+# Check if backup is complete
+result=$(diff-cli dirs source/ backup/ --json)
+different=$(echo "$result" | jq -r '.summary.different')
+only_in_source=$(echo "$result" | jq -r '.summary.only_in_first')
+
+if [ "$different" -eq 0 ] && [ "$only_in_source" -eq 0 ]; then
+    echo "Backup is complete and up-to-date"
+fi
+```
+
+### Monitor configuration changes
+```bash
+# Watch for config changes with logging
+diff-cli watch config.ini config.ini.new --format minimal | while IFS= read -r line; do
+    echo "$(date): $line" >> config_changes.log
+done
+```
+
+## Error Handling
+
+Common error conditions:
+- **File not found**: Exit code 2, stderr message
+- **Permission denied**: Exit code 2, stderr message  
+- **Binary files**: Exit code 2, "Binary files cannot be compared" message
+- **Directory not found**: Exit code 2, stderr message
+
+Error output in JSON mode:
+```json
+{
+  "error": "Binary files cannot be compared in text mode",
+  "exit_code": 2
+}
+```
+
+## Integration Examples
+
+### With jq for processing
+```bash
+# Extract only the added lines
+diff-cli files old.txt new.txt --json | jq -r '.diff[] | select(startswith("+") and (startswith("+++") | not))'
+
+# Get summary statistics
+diff-cli dirs project/ backup/ --json | jq '.summary'
+```
+
+### In shell scripts
+```bash
+#!/bin/bash
+# Backup validation script
+
+source_dir="$1"
+backup_dir="$2"
+
+result=$(diff-cli dirs "$source_dir" "$backup_dir" --json)
+exit_code=$?
+
+if [ $exit_code -eq 0 ]; then
+    echo "✓ Backup is identical to source"
+elif [ $exit_code -eq 1 ]; then
+    different=$(echo "$result" | jq -r '.summary.different')
+    missing=$(echo "$result" | jq -r '.summary.only_in_first') 
+    echo "⚠ Backup differs: $different files different, $missing files missing"
+else
+    echo "✗ Error occurred during comparison"
+fi
+
+exit $exit_code
+```
+
+### In Python (subprocess)
+```python
+import subprocess
+import json
+
+def compare_files(file1, file2, format='minimal'):
+    """Compare two files and return results."""
+    try:
+        result = subprocess.run([
+            'diff-cli', 'files', file1, file2, 
+            '--format', format, '--json'
+        ], capture_output=True, text=True, check=False)
+        
+        if result.returncode in [0, 1]:  # Success or diff found
+            return json.loads(result.stdout)
+        else:  # Error occurred
+            return {"error": result.stderr, "exit_code": result.returncode}
+    except subprocess.SubprocessError as e:
+        return {"error": str(e), "exit_code": -1}
+
+# Usage
+diff_result = compare_files('file1.txt', 'file2.txt')
+if diff_result.get('identical'):
+    print("Files are identical")
+else:
+    print(f"Files differ: {diff_result.get('changes', 'unknown')} changes")
+```
+
+## Prerequisites
+
+- Python 3.9+
+- Files must be readable (check permissions)
+- For directory comparison, directories must be accessible
+- Text files only (binary files return error)
+
+## Performance Notes
+
+- Large files: Use `--format minimal` for fastest comparison
+- Directory comparison: Recursive mode can be slow on large trees
+- Watch mode: Higher intervals reduce CPU usage
+- JSON output: Slightly slower due to formatting overhead
+
+## Related Tools
+
+- Standard `diff` command (POSIX)
+- `git diff` for version control
+- `rsync --dry-run` for directory synchronization
+- `cmp` for binary file comparison

diff_cli-0.1.0/diffcli/__init__.py

@@ -0,0 +1,2 @@
+"""diff-cli: File and text differ with multiple output formats."""
+__version__ = "0.1.0"

diff_cli-0.1.0/diffcli/cli.py

@@ -0,0 +1,452 @@
+#!/usr/bin/env python3
+"""diff-cli: File and text differ with multiple output formats."""
+
+import os
+import sys
+import json
+import time
+import difflib
+import threading
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+import click
+
+
+def colorize_diff_line(line: str, color_enabled: bool = True) -> str:
+    """Add color to diff lines if color is enabled."""
+    if not color_enabled or not sys.stdout.isatty():
+        return line
+    
+    if line.startswith('+++') or line.startswith('---'):
+        return click.style(line, fg='white', bold=True)
+    elif line.startswith('@@'):
+        return click.style(line, fg='cyan', bold=True)
+    elif line.startswith('+'):
+        return click.style(line, fg='green')
+    elif line.startswith('-'):
+        return click.style(line, fg='red')
+    elif line.startswith('?'):
+        return click.style(line, fg='yellow')
+    else:
+        return line
+
+
+def normalize_text(text: str, ignore_whitespace: bool = False, 
+                  ignore_case: bool = False, ignore_blank_lines: bool = False) -> str:
+    """Normalize text according to ignore options."""
+    if ignore_case:
+        text = text.lower()
+    
+    if ignore_blank_lines:
+        lines = [line for line in text.split('\n') if line.strip()]
+        text = '\n'.join(lines)
+    
+    if ignore_whitespace:
+        # Replace multiple whitespace with single space, strip line ends
+        lines = [' '.join(line.split()) for line in text.split('\n')]
+        text = '\n'.join(lines)
+    
+    return text
+
+
+def files_are_identical(file1: Path, file2: Path, ignore_whitespace: bool = False,
+                       ignore_case: bool = False, ignore_blank_lines: bool = False) -> bool:
+    """Check if two files are identical after normalization."""
+    try:
+        with open(file1, 'r', encoding='utf-8') as f1, open(file2, 'r', encoding='utf-8') as f2:
+            text1 = normalize_text(f1.read(), ignore_whitespace, ignore_case, ignore_blank_lines)
+            text2 = normalize_text(f2.read(), ignore_whitespace, ignore_case, ignore_blank_lines)
+            return text1 == text2
+    except UnicodeDecodeError:
+        # Binary comparison for non-text files
+        with open(file1, 'rb') as f1, open(file2, 'rb') as f2:
+            return f1.read() == f2.read()
+
+
+def unified_diff(text1: str, text2: str, filename1: str = 'file1', 
+                filename2: str = 'file2', context: int = 3) -> List[str]:
+    """Generate unified diff between two texts."""
+    lines1 = text1.splitlines(keepends=True)
+    lines2 = text2.splitlines(keepends=True)
+    
+    return list(difflib.unified_diff(
+        lines1, lines2,
+        fromfile=filename1,
+        tofile=filename2,
+        n=context
+    ))
+
+
+def side_by_side_diff(text1: str, text2: str, width: int = 80) -> List[str]:
+    """Generate side-by-side diff between two texts."""
+    lines1 = text1.splitlines()
+    lines2 = text2.splitlines()
+    
+    max_len = max(len(lines1), len(lines2))
+    col_width = width // 2 - 2
+    
+    result = []
+    result.append(f"{'File 1':<{col_width}} | {'File 2':<{col_width}}")
+    result.append(f"{'-' * col_width} | {'-' * col_width}")
+    
+    for i in range(max_len):
+        left = lines1[i] if i < len(lines1) else ""
+        right = lines2[i] if i < len(lines2) else ""
+        
+        # Truncate long lines
+        if len(left) > col_width:
+            left = left[:col_width-3] + "..."
+        if len(right) > col_width:
+            right = right[:col_width-3] + "..."
+        
+        # Determine line status
+        if i >= len(lines1):
+            marker = "+"
+        elif i >= len(lines2):
+            marker = "-"
+        elif left != right:
+            marker = "!"
+        else:
+            marker = " "
+            
+        result.append(f"{left:<{col_width}} {marker} {right:<{col_width}}")
+    
+    return result
+
+
+def context_diff(text1: str, text2: str, filename1: str = 'file1', 
+                filename2: str = 'file2', context: int = 3) -> List[str]:
+    """Generate context diff between two texts."""
+    lines1 = text1.splitlines(keepends=True)
+    lines2 = text2.splitlines(keepends=True)
+    
+    return list(difflib.context_diff(
+        lines1, lines2,
+        fromfile=filename1,
+        tofile=filename2,
+        n=context
+    ))
+
+
+def minimal_diff(text1: str, text2: str) -> Dict[str, Any]:
+    """Generate minimal diff summary."""
+    lines1 = text1.splitlines()
+    lines2 = text2.splitlines()
+    
+    if lines1 == lines2:
+        return {
+            "identical": True,
+            "changes": 0,
+            "additions": 0,
+            "deletions": 0
+        }
+    
+    # Use difflib to get a basic comparison
+    diff = list(difflib.unified_diff(lines1, lines2, n=0))
+    
+    additions = sum(1 for line in diff if line.startswith('+') and not line.startswith('+++'))
+    deletions = sum(1 for line in diff if line.startswith('-') and not line.startswith('---'))
+    
+    return {
+        "identical": False,
+        "changes": additions + deletions,
+        "additions": additions,
+        "deletions": deletions,
+        "total_lines_1": len(lines1),
+        "total_lines_2": len(lines2)
+    }
+
+
+def scan_directory(directory: Path, recursive: bool = True) -> List[Path]:
+    """Scan directory for files."""
+    files = []
+    if recursive:
+        for root, dirs, filenames in os.walk(directory):
+            for filename in filenames:
+                files.append(Path(root) / filename)
+    else:
+        for item in directory.iterdir():
+            if item.is_file():
+                files.append(item)
+    return sorted(files)
+
+
+def compare_directories(dir1: Path, dir2: Path, recursive: bool = True) -> Dict[str, Any]:
+    """Compare two directories."""
+    files1 = {f.relative_to(dir1): f for f in scan_directory(dir1, recursive)}
+    files2 = {f.relative_to(dir2): f for f in scan_directory(dir2, recursive)}
+    
+    all_files = set(files1.keys()) | set(files2.keys())
+    only_in_1 = set(files1.keys()) - set(files2.keys())
+    only_in_2 = set(files2.keys()) - set(files1.keys())
+    common_files = set(files1.keys()) & set(files2.keys())
+    
+    different_files = []
+    identical_files = []
+    
+    for rel_path in common_files:
+        file1 = files1[rel_path]
+        file2 = files2[rel_path]
+        
+        if files_are_identical(file1, file2):
+            identical_files.append(str(rel_path))
+        else:
+            different_files.append(str(rel_path))
+    
+    return {
+        "total_files": len(all_files),
+        "only_in_first": sorted([str(f) for f in only_in_1]),
+        "only_in_second": sorted([str(f) for f in only_in_2]),
+        "different": sorted(different_files),
+        "identical": sorted(identical_files),
+        "summary": {
+            "only_in_first": len(only_in_1),
+            "only_in_second": len(only_in_2),  
+            "different": len(different_files),
+            "identical": len(identical_files)
+        }
+    }
+
+
+@click.group()
+@click.version_option(version="0.1.0", prog_name="diff-cli")
+def cli():
+    """diff-cli: File and text differ with multiple output formats."""
+    pass
+
+
+@cli.command()
+@click.argument('file1', type=click.Path(exists=True, path_type=Path))
+@click.argument('file2', type=click.Path(exists=True, path_type=Path))
+@click.option('--format', '-f', type=click.Choice(['unified', 'side-by-side', 'context', 'minimal']),
+              default='unified', help='Diff output format')
+@click.option('--context', '-n', default=3, help='Number of context lines')
+@click.option('--ignore-whitespace', '-w', is_flag=True, help='Ignore whitespace differences')
+@click.option('--ignore-case', '-i', is_flag=True, help='Ignore case differences')  
+@click.option('--ignore-blank-lines', '-B', is_flag=True, help='Ignore blank lines')
+@click.option('--no-color', is_flag=True, help='Disable colored output')
+@click.option('--json', 'output_json', is_flag=True, help='Output in JSON format')
+def files(file1: Path, file2: Path, format: str, context: int, 
+         ignore_whitespace: bool, ignore_case: bool, ignore_blank_lines: bool,
+         no_color: bool, output_json: bool):
+    """Compare two files."""
+    try:
+        with open(file1, 'r', encoding='utf-8') as f1, open(file2, 'r', encoding='utf-8') as f2:
+            text1 = normalize_text(f1.read(), ignore_whitespace, ignore_case, ignore_blank_lines)
+            text2 = normalize_text(f2.read(), ignore_whitespace, ignore_case, ignore_blank_lines)
+    except UnicodeDecodeError:
+        if output_json:
+            click.echo(json.dumps({"error": "Binary files cannot be compared in text mode", "exit_code": 2}))
+        else:
+            click.echo("Error: Binary files cannot be compared in text mode", err=True)
+        sys.exit(2)
+    
+    # Check if files are identical
+    identical = text1 == text2
+    
+    if output_json:
+        result = {
+            "files": [str(file1), str(file2)],
+            "identical": identical,
+            "format": format
+        }
+        
+        if format == 'minimal':
+            result.update(minimal_diff(text1, text2))
+        else:
+            if format == 'unified':
+                diff_lines = unified_diff(text1, text2, str(file1), str(file2), context)
+            elif format == 'side-by-side':
+                diff_lines = side_by_side_diff(text1, text2)
+            elif format == 'context':
+                diff_lines = context_diff(text1, text2, str(file1), str(file2), context)
+            
+            result["diff"] = diff_lines
+        
+        click.echo(json.dumps(result, indent=2))
+    else:
+        if identical:
+            click.echo("Files are identical")
+        else:
+            if format == 'minimal':
+                summary = minimal_diff(text1, text2)
+                click.echo(f"Files differ: {summary['changes']} changes ({summary['additions']} additions, {summary['deletions']} deletions)")
+            else:
+                if format == 'unified':
+                    diff_lines = unified_diff(text1, text2, str(file1), str(file2), context)
+                elif format == 'side-by-side':
+                    diff_lines = side_by_side_diff(text1, text2)
+                elif format == 'context':
+                    diff_lines = context_diff(text1, text2, str(file1), str(file2), context)
+                
+                color_enabled = not no_color
+                for line in diff_lines:
+                    click.echo(colorize_diff_line(line.rstrip(), color_enabled))
+    
+    sys.exit(0 if identical else 1)
+
+
+@cli.command()
+@click.argument('text1')
+@click.argument('text2')
+@click.option('--format', '-f', type=click.Choice(['unified', 'side-by-side', 'context', 'minimal']),
+              default='unified', help='Diff output format')
+@click.option('--context', '-n', default=3, help='Number of context lines')
+@click.option('--ignore-whitespace', '-w', is_flag=True, help='Ignore whitespace differences')
+@click.option('--ignore-case', '-i', is_flag=True, help='Ignore case differences')
+@click.option('--ignore-blank-lines', '-B', is_flag=True, help='Ignore blank lines')
+@click.option('--no-color', is_flag=True, help='Disable colored output')
+@click.option('--json', 'output_json', is_flag=True, help='Output in JSON format')
+def text(text1: str, text2: str, format: str, context: int,
+         ignore_whitespace: bool, ignore_case: bool, ignore_blank_lines: bool,
+         no_color: bool, output_json: bool):
+    """Compare two text strings."""
+    normalized_text1 = normalize_text(text1, ignore_whitespace, ignore_case, ignore_blank_lines)
+    normalized_text2 = normalize_text(text2, ignore_whitespace, ignore_case, ignore_blank_lines)
+    
+    identical = normalized_text1 == normalized_text2
+    
+    if output_json:
+        result = {
+            "texts": [text1, text2],
+            "identical": identical,
+            "format": format
+        }
+        
+        if format == 'minimal':
+            result.update(minimal_diff(normalized_text1, normalized_text2))
+        else:
+            if format == 'unified':
+                diff_lines = unified_diff(normalized_text1, normalized_text2, "text1", "text2", context)
+            elif format == 'side-by-side':
+                diff_lines = side_by_side_diff(normalized_text1, normalized_text2)
+            elif format == 'context':
+                diff_lines = context_diff(normalized_text1, normalized_text2, "text1", "text2", context)
+            
+            result["diff"] = diff_lines
+        
+        click.echo(json.dumps(result, indent=2))
+    else:
+        if identical:
+            click.echo("Texts are identical")
+        else:
+            if format == 'minimal':
+                summary = minimal_diff(normalized_text1, normalized_text2)
+                click.echo(f"Texts differ: {summary['changes']} changes ({summary['additions']} additions, {summary['deletions']} deletions)")
+            else:
+                if format == 'unified':
+                    diff_lines = unified_diff(normalized_text1, normalized_text2, "text1", "text2", context)
+                elif format == 'side-by-side':
+                    diff_lines = side_by_side_diff(normalized_text1, normalized_text2)
+                elif format == 'context':
+                    diff_lines = context_diff(normalized_text1, normalized_text2, "text1", "text2", context)
+                
+                color_enabled = not no_color
+                for line in diff_lines:
+                    click.echo(colorize_diff_line(line.rstrip(), color_enabled))
+    
+    sys.exit(0 if identical else 1)
+
+
+@cli.command()
+@click.argument('dir1', type=click.Path(exists=True, file_okay=False, path_type=Path))
+@click.argument('dir2', type=click.Path(exists=True, file_okay=False, path_type=Path))
+@click.option('--recursive', '-r', is_flag=True, default=True, help='Compare directories recursively')
+@click.option('--json', 'output_json', is_flag=True, help='Output in JSON format')
+def dirs(dir1: Path, dir2: Path, recursive: bool, output_json: bool):
+    """Compare two directories."""
+    result = compare_directories(dir1, dir2, recursive)
+    
+    if output_json:
+        click.echo(json.dumps(result, indent=2))
+    else:
+        summary = result["summary"]
+        click.echo(f"Directory comparison: {dir1} vs {dir2}")
+        click.echo(f"Total files: {result['total_files']}")
+        click.echo(f"Only in first: {summary['only_in_first']}")
+        click.echo(f"Only in second: {summary['only_in_second']}")
+        click.echo(f"Different: {summary['different']}")
+        click.echo(f"Identical: {summary['identical']}")
+        
+        if result['only_in_first']:
+            click.echo(f"\nFiles only in {dir1}:")
+            for f in result['only_in_first']:
+                click.echo(f"  - {f}")
+        
+        if result['only_in_second']:
+            click.echo(f"\nFiles only in {dir2}:")
+            for f in result['only_in_second']:
+                click.echo(f"  + {f}")
+        
+        if result['different']:
+            click.echo(f"\nDifferent files:")
+            for f in result['different']:
+                click.echo(f"  ! {f}")
+    
+    # Exit with 1 if there are any differences
+    has_differences = (summary['only_in_first'] > 0 or 
+                      summary['only_in_second'] > 0 or 
+                      summary['different'] > 0)
+    sys.exit(1 if has_differences else 0)
+
+
+@cli.command()
+@click.argument('file1', type=click.Path(exists=True, path_type=Path))
+@click.argument('file2', type=click.Path(exists=True, path_type=Path))
+@click.option('--interval', '-i', default=1.0, help='Check interval in seconds')
+@click.option('--format', '-f', type=click.Choice(['unified', 'side-by-side', 'context', 'minimal']),
+              default='unified', help='Diff output format')
+@click.option('--no-color', is_flag=True, help='Disable colored output')
+def watch(file1: Path, file2: Path, interval: float, format: str, no_color: bool):
+    """Watch two files for changes and show diff when they change."""
+    click.echo(f"Watching {file1} and {file2} for changes (Ctrl+C to stop)...")
+    
+    last_mtime1 = file1.stat().st_mtime if file1.exists() else 0
+    last_mtime2 = file2.stat().st_mtime if file2.exists() else 0
+    
+    try:
+        while True:
+            time.sleep(interval)
+            
+            current_mtime1 = file1.stat().st_mtime if file1.exists() else 0
+            current_mtime2 = file2.stat().st_mtime if file2.exists() else 0
+            
+            if current_mtime1 != last_mtime1 or current_mtime2 != last_mtime2:
+                click.echo(f"\n--- Change detected at {time.strftime('%Y-%m-%d %H:%M:%S')} ---")
+                
+                try:
+                    with open(file1, 'r', encoding='utf-8') as f1, open(file2, 'r', encoding='utf-8') as f2:
+                        text1 = f1.read()
+                        text2 = f2.read()
+                    
+                    if text1 == text2:
+                        click.echo("Files are now identical")
+                    else:
+                        if format == 'minimal':
+                            summary = minimal_diff(text1, text2)
+                            click.echo(f"Files differ: {summary['changes']} changes")
+                        else:
+                            if format == 'unified':
+                                diff_lines = unified_diff(text1, text2, str(file1), str(file2))
+                            elif format == 'side-by-side':
+                                diff_lines = side_by_side_diff(text1, text2)
+                            elif format == 'context':
+                                diff_lines = context_diff(text1, text2, str(file1), str(file2))
+                            
+                            color_enabled = not no_color
+                            for line in diff_lines:
+                                click.echo(colorize_diff_line(line.rstrip(), color_enabled))
+                
+                except Exception as e:
+                    click.echo(f"Error reading files: {e}", err=True)
+                
+                last_mtime1 = current_mtime1
+                last_mtime2 = current_mtime2
+                
+    except KeyboardInterrupt:
+        click.echo("\nStopped watching.")
+
+
+if __name__ == '__main__':
+    cli()

diff_cli-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "diff-cli"
+version = "0.1.0"
+description = "File and text differ with multiple output formats"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "Marcus", email = "marcus.builds.things@gmail.com" }]
+keywords = ["diff", "compare", "cli", "unified", "side-by-side", "text"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Text Processing :: General",
+    "Topic :: Utilities",
+]
+requires-python = ">=3.9"
+dependencies = ["click>=8.0"]
+
+[project.scripts]
+diff-cli = "diffcli.cli:cli"
+
+[project.urls]
+Homepage = "https://github.com/marcusbuildsthings-droid/diff-cli"
+Repository = "https://github.com/marcusbuildsthings-droid/diff-cli"
+
+[tool.hatch.build.targets.wheel]
+packages = ["diffcli"]