lawkit-python 2.1.0__tar.gz → 2.1.2__tar.gz

{lawkit_python-2.1.0 → lawkit_python-2.1.2}/.gitignore

@@ -116,4 +116,7 @@ secrets.json
 # Large test files
 *.csv.large
 *.xlsx.large
-*.json.large
+*.json.large
+
+# Test directories
+test-packages/

{lawkit_python-2.1.0 → lawkit_python-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lawkit-python
-Version: 2.1.0
+Version: 2.1.2
 Summary: Python wrapper for lawkit - Statistical law analysis toolkit for fraud detection and data quality assessment
 Project-URL: Homepage, https://github.com/kako-jun/lawkit
 Project-URL: Repository, https://github.com/kako-jun/lawkit
@@ -55,14 +55,14 @@ This will automatically download the appropriate `lawkit` binary for your system
 ```python
 import lawkit
 
-# Analyze financial data with Benford's Law
+# Analyze financial data with Benford Law
 result = lawkit.analyze_benford('financial_data.csv')
 print(result)
 
 # Get structured JSON output
 json_result = lawkit.analyze_benford(
     'accounting.csv',
-    lawkit.LawkitOptions(format='csv', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Risk level: {json_result.risk_level}")
 print(f"P-value: {json_result.p_value}")
@@ -70,7 +70,7 @@ print(f"P-value: {json_result.p_value}")
 # Check if data follows Pareto principle (80/20 rule)
 pareto_result = lawkit.analyze_pareto(
     'sales_data.csv',
-    lawkit.LawkitOptions(output='json', gini_coefficient=True)
+    lawkit.LawkitOptions(format='json', gini_coefficient=True)
 )
 print(f"Gini coefficient: {pareto_result.gini_coefficient}")
 print(f"80/20 concentration: {pareto_result.concentration_80_20}")
@@ -80,9 +80,9 @@ print(f"80/20 concentration: {pareto_result.concentration_80_20}")
 
 ### Statistical Laws Supported
 
-- **Benford's Law**: Detect fraud and anomalies in numerical data
+- **Benford Law**: Detect fraud and anomalies in numerical data
 - **Pareto Principle**: Analyze 80/20 distributions and concentration
-- **Zipf's Law**: Analyze word frequencies and power-law distributions
+- **Zipf Law**: Analyze word frequencies and power-law distributions
 - **Normal Distribution**: Test for normality and detect outliers
 - **Poisson Distribution**: Analyze rare events and count data
 
@@ -109,7 +109,7 @@ print(f"80/20 concentration: {pareto_result.concentration_80_20}")
 ```python
 import lawkit
 
-# Analyze with Benford's Law
+# Analyze with Benford Law
 result = lawkit.analyze_benford('invoice_data.csv')
 print(result)
 
@@ -159,13 +159,27 @@ if normal_result.p_value < 0.05:
     if normal_result.outliers:
         print(f"Found {len(normal_result.outliers)} outliers")
 
-# Multi-law comparison
-comparison = lawkit.compare_laws(
+# Multi-law analysis
+analysis = lawkit.analyze_laws(
     'complex_dataset.csv',
-    lawkit.LawkitOptions(output='json')
+    lawkit.LawkitOptions(format='json', laws='benf,pareto,zipf')
 )
-print(f"Best fitting law: {comparison.data.get('best_law')}")
-print(f"Overall risk level: {comparison.risk_level}")
+print(f"Analysis results: {analysis.data}")
+print(f"Overall risk level: {analysis.risk_level}")
+
+# Data validation
+validation = lawkit.validate_laws(
+    'complex_dataset.csv',
+    lawkit.LawkitOptions(format='json', consistency_check=True)
+)
+print(f"Validation status: {validation.data}")
+
+# Conflict diagnosis
+diagnosis = lawkit.diagnose_laws(
+    'complex_dataset.csv',
+    lawkit.LawkitOptions(format='json', report='detailed')
+)
+print(f"Diagnosis: {diagnosis.data}")
 ```
 
 ### Generate Sample Data
@@ -173,7 +187,7 @@ print(f"Overall risk level: {comparison.risk_level}")
 ```python
 import lawkit
 
-# Generate Benford's Law compliant data
+# Generate Benford Law compliant data
 benford_data = lawkit.generate_data('benf', samples=1000, seed=42)
 print(benford_data)
 
@@ -205,7 +219,7 @@ csv_data = """amount
 result = lawkit.analyze_string(
     csv_data,
     'benf',
-    lawkit.LawkitOptions(format='csv', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Risk assessment: {result.risk_level}")
 
@@ -214,7 +228,7 @@ json_data = '{"values": [12, 23, 34, 45, 56, 67, 78, 89]}'
 result = lawkit.analyze_string(
     json_data,
     'normal',
-    lawkit.LawkitOptions(format='json', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Is normal: {result.p_value > 0.05}")
 ```
@@ -338,7 +352,7 @@ result = lawkit.analyze_benford('invoices.csv',
 if result.risk_level in ['High', 'Critical']:
     print("🚨 Potential fraud detected in invoice data")
     print(f"Statistical significance: p={result.p_value:.6f}")
-    print(f"Deviation from Benford's Law: {result.mad:.2f}%")
+    print(f"Deviation from Benford Law: {result.mad:.2f}%")
 ```
 
 ### Business Intelligence
@@ -386,7 +400,7 @@ import lawkit
 result = lawkit.analyze_zipf('document.txt',
                             lawkit.LawkitOptions(output='json'))
 
-print(f"Text follows Zipf's Law: {result.p_value > 0.05}")
+print(f"Text follows Zipf Law: {result.p_value > 0.05}")
 print(f"Power law exponent: {result.exponent:.3f}")
 ```
 
@@ -394,12 +408,15 @@ print(f"Power law exponent: {result.exponent:.3f}")
 
 ### Main Functions
 
-- `analyze_benford(input_data, options)` - Benford's Law analysis
+- `analyze_benford(input_data, options)` - Benford Law analysis
 - `analyze_pareto(input_data, options)` - Pareto principle analysis  
-- `analyze_zipf(input_data, options)` - Zipf's Law analysis
+- `analyze_zipf(input_data, options)` - Zipf Law analysis
 - `analyze_normal(input_data, options)` - Normal distribution analysis
 - `analyze_poisson(input_data, options)` - Poisson distribution analysis
-- `compare_laws(input_data, options)` - Multi-law comparison
+- `analyze_laws(input_data, options)` - Multi-law analysis
+- `validate_laws(input_data, options)` - Data validation and consistency check
+- `diagnose_laws(input_data, options)` - Conflict diagnosis and detailed reporting
+- `compare_laws(input_data, options)` - Alias for analyze_laws (backward compatibility)
 - `generate_data(law_type, samples, **kwargs)` - Generate sample data
 - `analyze_string(content, law_type, options)` - Analyze string data directly
 

{lawkit_python-2.1.0 → lawkit_python-2.1.2}/README.md

@@ -15,14 +15,14 @@ This will automatically download the appropriate `lawkit` binary for your system
 ```python
 import lawkit
 
-# Analyze financial data with Benford's Law
+# Analyze financial data with Benford Law
 result = lawkit.analyze_benford('financial_data.csv')
 print(result)
 
 # Get structured JSON output
 json_result = lawkit.analyze_benford(
     'accounting.csv',
-    lawkit.LawkitOptions(format='csv', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Risk level: {json_result.risk_level}")
 print(f"P-value: {json_result.p_value}")
@@ -30,7 +30,7 @@ print(f"P-value: {json_result.p_value}")
 # Check if data follows Pareto principle (80/20 rule)
 pareto_result = lawkit.analyze_pareto(
     'sales_data.csv',
-    lawkit.LawkitOptions(output='json', gini_coefficient=True)
+    lawkit.LawkitOptions(format='json', gini_coefficient=True)
 )
 print(f"Gini coefficient: {pareto_result.gini_coefficient}")
 print(f"80/20 concentration: {pareto_result.concentration_80_20}")
@@ -40,9 +40,9 @@ print(f"80/20 concentration: {pareto_result.concentration_80_20}")
 
 ### Statistical Laws Supported
 
-- **Benford's Law**: Detect fraud and anomalies in numerical data
+- **Benford Law**: Detect fraud and anomalies in numerical data
 - **Pareto Principle**: Analyze 80/20 distributions and concentration
-- **Zipf's Law**: Analyze word frequencies and power-law distributions
+- **Zipf Law**: Analyze word frequencies and power-law distributions
 - **Normal Distribution**: Test for normality and detect outliers
 - **Poisson Distribution**: Analyze rare events and count data
 
@@ -69,7 +69,7 @@ print(f"80/20 concentration: {pareto_result.concentration_80_20}")
 ```python
 import lawkit
 
-# Analyze with Benford's Law
+# Analyze with Benford Law
 result = lawkit.analyze_benford('invoice_data.csv')
 print(result)
 
@@ -119,13 +119,27 @@ if normal_result.p_value < 0.05:
     if normal_result.outliers:
         print(f"Found {len(normal_result.outliers)} outliers")
 
-# Multi-law comparison
-comparison = lawkit.compare_laws(
+# Multi-law analysis
+analysis = lawkit.analyze_laws(
     'complex_dataset.csv',
-    lawkit.LawkitOptions(output='json')
+    lawkit.LawkitOptions(format='json', laws='benf,pareto,zipf')
 )
-print(f"Best fitting law: {comparison.data.get('best_law')}")
-print(f"Overall risk level: {comparison.risk_level}")
+print(f"Analysis results: {analysis.data}")
+print(f"Overall risk level: {analysis.risk_level}")
+
+# Data validation
+validation = lawkit.validate_laws(
+    'complex_dataset.csv',
+    lawkit.LawkitOptions(format='json', consistency_check=True)
+)
+print(f"Validation status: {validation.data}")
+
+# Conflict diagnosis
+diagnosis = lawkit.diagnose_laws(
+    'complex_dataset.csv',
+    lawkit.LawkitOptions(format='json', report='detailed')
+)
+print(f"Diagnosis: {diagnosis.data}")
 ```
 
 ### Generate Sample Data
@@ -133,7 +147,7 @@ print(f"Overall risk level: {comparison.risk_level}")
 ```python
 import lawkit
 
-# Generate Benford's Law compliant data
+# Generate Benford Law compliant data
 benford_data = lawkit.generate_data('benf', samples=1000, seed=42)
 print(benford_data)
 
@@ -165,7 +179,7 @@ csv_data = """amount
 result = lawkit.analyze_string(
     csv_data,
     'benf',
-    lawkit.LawkitOptions(format='csv', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Risk assessment: {result.risk_level}")
 
@@ -174,7 +188,7 @@ json_data = '{"values": [12, 23, 34, 45, 56, 67, 78, 89]}'
 result = lawkit.analyze_string(
     json_data,
     'normal',
-    lawkit.LawkitOptions(format='json', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Is normal: {result.p_value > 0.05}")
 ```
@@ -298,7 +312,7 @@ result = lawkit.analyze_benford('invoices.csv',
 if result.risk_level in ['High', 'Critical']:
     print("🚨 Potential fraud detected in invoice data")
     print(f"Statistical significance: p={result.p_value:.6f}")
-    print(f"Deviation from Benford's Law: {result.mad:.2f}%")
+    print(f"Deviation from Benford Law: {result.mad:.2f}%")
 ```
 
 ### Business Intelligence
@@ -346,7 +360,7 @@ import lawkit
 result = lawkit.analyze_zipf('document.txt',
                             lawkit.LawkitOptions(output='json'))
 
-print(f"Text follows Zipf's Law: {result.p_value > 0.05}")
+print(f"Text follows Zipf Law: {result.p_value > 0.05}")
 print(f"Power law exponent: {result.exponent:.3f}")
 ```
 
@@ -354,12 +368,15 @@ print(f"Power law exponent: {result.exponent:.3f}")
 
 ### Main Functions
 
-- `analyze_benford(input_data, options)` - Benford's Law analysis
+- `analyze_benford(input_data, options)` - Benford Law analysis
 - `analyze_pareto(input_data, options)` - Pareto principle analysis  
-- `analyze_zipf(input_data, options)` - Zipf's Law analysis
+- `analyze_zipf(input_data, options)` - Zipf Law analysis
 - `analyze_normal(input_data, options)` - Normal distribution analysis
 - `analyze_poisson(input_data, options)` - Poisson distribution analysis
-- `compare_laws(input_data, options)` - Multi-law comparison
+- `analyze_laws(input_data, options)` - Multi-law analysis
+- `validate_laws(input_data, options)` - Data validation and consistency check
+- `diagnose_laws(input_data, options)` - Conflict diagnosis and detailed reporting
+- `compare_laws(input_data, options)` - Alias for analyze_laws (backward compatibility)
 - `generate_data(law_type, samples, **kwargs)` - Generate sample data
 - `analyze_string(content, law_type, options)` - Analyze string data directly
 

{lawkit_python-2.1.0 → lawkit_python-2.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lawkit-python"
-version = "2.1.0"
+version = "2.1.2"
 description = "Python wrapper for lawkit - Statistical law analysis toolkit for fraud detection and data quality assessment"
 readme = "README.md"
 license = "MIT"

{lawkit_python-2.1.0 → lawkit_python-2.1.2}/src/lawkit/__init__.py

@@ -13,6 +13,9 @@ from .lawkit import (
     analyze_zipf,
     analyze_normal,
     analyze_poisson,
+    analyze_laws,
+    validate_laws,
+    diagnose_laws,
     compare_laws,
     generate_data,
     analyze_string,
@@ -38,6 +41,9 @@ __all__ = [
     "analyze_zipf",
     "analyze_normal",
     "analyze_poisson",
+    "analyze_laws",
+    "validate_laws",
+    "diagnose_laws",
     "compare_laws",
     
     # Utility functions

{lawkit_python-2.1.0 → lawkit_python-2.1.2}/src/lawkit/lawkit.py

@@ -22,20 +22,44 @@ LawType = Literal["benf", "pareto", "zipf", "normal", "poisson"]
 class LawkitOptions:
     """Options for lawkit operations"""
     format: Optional[Format] = None
-    output: Optional[OutputFormat] = None
-    min_count: Optional[int] = None
-    threshold: Optional[float] = None
-    confidence: Optional[float] = None
+    quiet: bool = False
     verbose: bool = False
+    filter: Optional[str] = None
+    min_count: Optional[int] = None
     optimize: bool = False
-    international: bool = False
+    
+    # Integration-specific options
+    laws: Optional[str] = None  # "benf,pareto,zipf,normal,poisson"
+    focus: Optional[str] = None  # "quality", "concentration", "distribution", "anomaly"
+    threshold: Optional[float] = None  # Conflict detection threshold
+    recommend: bool = False
+    report: Optional[str] = None  # "summary", "detailed", "conflicting"
+    consistency_check: bool = False
+    cross_validation: bool = False
+    confidence_level: Optional[float] = None
+    purpose: Optional[str] = None  # "quality", "fraud", "concentration", "anomaly", "distribution", "general"
+    
     # Law-specific options
     gini_coefficient: bool = False
     percentiles: Optional[str] = None
     business_analysis: bool = False
+    concentration: Optional[float] = None
+    
+    # Benford-specific options
+    threshold_level: Optional[str] = None  # "low", "medium", "high", "critical", "auto"
+    
+    # Generate-specific options
+    samples: Optional[int] = None
+    seed: Optional[int] = None
+    output_file: Optional[str] = None
+    fraud_rate: Optional[float] = None
+    range: Optional[str] = None  # "1,100000"
+    scale: Optional[float] = None
+    
     # Statistical options
     test_type: Optional[str] = None
     alpha: Optional[float] = None
+    
     # Advanced options
     outlier_detection: bool = False
     time_series: bool = False
@@ -144,14 +168,17 @@ def _execute_lawkit(args: List[str]) -> tuple[str, str]:
             [lawkit_path] + args,
             capture_output=True,
             text=True,
-            check=True
+            check=False  # Don't raise exception on non-zero exit
         )
-        return result.stdout, result.stderr
-    except subprocess.CalledProcessError as e:
+        
+        # Exit codes 10-19 are typically warnings, not fatal errors
+        if result.returncode == 0 or (result.returncode >= 10 and result.returncode <= 19):
+            return result.stdout, result.stderr
+        
         raise LawkitError(
-            f"lawkit exited with code {e.returncode}",
-            e.returncode,
-            e.stderr or ""
+            f"lawkit exited with code {result.returncode}",
+            result.returncode,
+            result.stderr or ""
         )
     except FileNotFoundError:
         raise LawkitError(
@@ -192,10 +219,14 @@ def analyze_benford(
     # Add common options
     _add_common_options(args, options)
     
+    # Add Benford-specific options
+    if options.threshold_level:
+        args.extend(["--threshold", options.threshold_level])
+    
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "benford")
@@ -238,6 +269,9 @@ def analyze_pareto(
     _add_common_options(args, options)
     
     # Add Pareto-specific options
+    if options.concentration is not None:
+        args.extend(["--concentration", str(options.concentration)])
+    
     if options.gini_coefficient:
         args.append("--gini-coefficient")
     
@@ -250,7 +284,7 @@ def analyze_pareto(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "pareto")
@@ -294,7 +328,7 @@ def analyze_zipf(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "zipf")
@@ -347,7 +381,7 @@ def analyze_normal(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "normal")
@@ -391,7 +425,7 @@ def analyze_poisson(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "poisson")
@@ -402,12 +436,12 @@ def analyze_poisson(
     return stdout
 
 
-def compare_laws(
+def analyze_laws(
     input_data: str,
     options: Optional[LawkitOptions] = None
 ) -> Union[str, LawkitResult]:
     """
-    Compare multiple statistical laws on the same data
+    Analyze data using multiple statistical laws (basic analysis)
     
     Args:
         input_data: Path to input file or '-' for stdin
@@ -417,17 +451,105 @@ def compare_laws(
         String output for text format, or LawkitResult for JSON format
         
     Examples:
-        >>> result = compare_laws('dataset.csv')
+        >>> result = analyze_laws('dataset.csv')
         >>> print(result)
         
-        >>> json_result = compare_laws('complex_data.json', 
-        ...                          LawkitOptions(output='json'))
+        >>> json_result = analyze_laws('complex_data.json', 
+        ...                          LawkitOptions(format='json'))
         >>> print(f"Risk level: {json_result.risk_level}")
     """
     if options is None:
         options = LawkitOptions()
     
-    args = ["compare", input_data]
+    args = ["analyze", input_data]
+    
+    # Add common options
+    _add_common_options(args, options)
+    
+    stdout, stderr = _execute_lawkit(args)
+    
+    # If output format is JSON, parse the result
+    if options.format == "json":
+        try:
+            json_data = json.loads(stdout)
+            return LawkitResult(json_data, "analyze")
+        except json.JSONDecodeError as e:
+            raise LawkitError(f"Failed to parse JSON output: {e}", -1, "")
+    
+    # Return raw output for other formats
+    return stdout
+
+
+def validate_laws(
+    input_data: str,
+    options: Optional[LawkitOptions] = None
+) -> Union[str, LawkitResult]:
+    """
+    Validate data consistency using multiple statistical laws
+    
+    Args:
+        input_data: Path to input file or '-' for stdin
+        options: Analysis options
+        
+    Returns:
+        String output for text format, or LawkitResult for JSON format
+        
+    Examples:
+        >>> result = validate_laws('dataset.csv')
+        >>> print(result)
+        
+        >>> json_result = validate_laws('complex_data.json', 
+        ...                           LawkitOptions(format='json'))
+        >>> print(f"Validation result: {json_result.data}")
+    """
+    if options is None:
+        options = LawkitOptions()
+    
+    args = ["validate", input_data]
+    
+    # Add common options
+    _add_common_options(args, options)
+    
+    stdout, stderr = _execute_lawkit(args)
+    
+    # If output format is JSON, parse the result
+    if options.format == "json":
+        try:
+            json_data = json.loads(stdout)
+            return LawkitResult(json_data, "validate")
+        except json.JSONDecodeError as e:
+            raise LawkitError(f"Failed to parse JSON output: {e}", -1, "")
+    
+    # Return raw output for other formats
+    return stdout
+
+
+def diagnose_laws(
+    input_data: str,
+    options: Optional[LawkitOptions] = None
+) -> Union[str, LawkitResult]:
+    """
+    Diagnose conflicts and generate detailed analysis report
+    
+    Args:
+        input_data: Path to input file or '-' for stdin
+        options: Analysis options
+        
+    Returns:
+        String output for text format, or LawkitResult for JSON format
+        
+    Examples:
+        >>> result = diagnose_laws('dataset.csv')
+        >>> print(result)
+        
+        >>> json_result = diagnose_laws('complex_data.json', 
+        ...                           LawkitOptions(format='json'))
+        >>> print(f"Diagnosis: {json_result.data}")
+    """
+    if options is None:
+        options = LawkitOptions()
+    
+    args = ["diagnose", input_data]
     
     # Add common options
     _add_common_options(args, options)
@@ -435,10 +557,10 @@ def compare_laws(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
-            return LawkitResult(json_data, "compare")
+            return LawkitResult(json_data, "diagnose")
         except json.JSONDecodeError as e:
             raise LawkitError(f"Failed to parse JSON output: {e}", -1, "")
     
@@ -446,10 +568,13 @@ def compare_laws(
     return stdout
 
 
+# Backward compatibility alias
+compare_laws = analyze_laws
+
+
 def generate_data(
     law_type: LawType,
-    samples: int = 1000,
-    seed: Optional[int] = None,
+    options: Optional[LawkitOptions] = None,
     **kwargs
 ) -> str:
     """
@@ -457,26 +582,46 @@ def generate_data(
     
     Args:
         law_type: Type of statistical law to use
-        samples: Number of samples to generate
-        seed: Random seed for reproducibility
-        **kwargs: Law-specific parameters
+        options: Generation options (samples, seed, etc.)
+        **kwargs: Law-specific parameters (deprecated, use options instead)
         
     Returns:
         Generated data as string
         
     Examples:
-        >>> data = generate_data('benf', samples=1000, seed=42)
+        >>> data = generate_data('benf', LawkitOptions(samples=1000, seed=42))
         >>> print(data)
         
-        >>> normal_data = generate_data('normal', samples=500, mean=100, stddev=15)
-        >>> pareto_data = generate_data('pareto', samples=1000, concentration=0.8)
+        >>> options = LawkitOptions(samples=500, fraud_rate=0.1, range="1,10000")
+        >>> normal_data = generate_data('normal', options)
+        >>> pareto_data = generate_data('pareto', LawkitOptions(concentration=0.8))
     """
-    args = ["generate", law_type, "--samples", str(samples)]
+    if options is None:
+        options = LawkitOptions()
     
-    if seed is not None:
-        args.extend(["--seed", str(seed)])
+    args = ["generate", law_type]
     
-    # Add law-specific parameters
+    # Add common options
+    _add_common_options(args, options)
+    
+    # Add generate-specific options
+    if options.samples is not None:
+        args.extend(["--samples", str(options.samples)])
+    
+    if options.seed is not None:
+        args.extend(["--seed", str(options.seed)])
+    
+    if options.output_file:
+        args.extend(["--output-file", options.output_file])
+    
+    if options.fraud_rate is not None:
+        args.extend(["--fraud-rate", str(options.fraud_rate)])
+    
+    # Note: --range option not available in current CLI
+    
+    # Note: --scale option may not be available for all law types
+    
+    # Add law-specific parameters (backward compatibility)
     for key, value in kwargs.items():
         key_formatted = key.replace("_", "-")
         args.extend([f"--{key_formatted}", str(value)])
@@ -539,29 +684,52 @@ def _add_common_options(args: List[str], options: LawkitOptions) -> None:
     if options.format:
         args.extend(["--format", options.format])
     
-    if options.output:
-        args.extend(["--output", options.output])
+    if options.quiet:
+        args.append("--quiet")
+    
+    if options.verbose:
+        args.append("--verbose")
+    
+    if options.filter:
+        args.extend(["--filter", options.filter])
     
     if options.min_count is not None:
         args.extend(["--min-count", str(options.min_count)])
     
+    if options.optimize:
+        args.append("--optimize")
+    
+    # Integration-specific options
+    if options.laws:
+        args.extend(["--laws", options.laws])
+    
+    if options.focus:
+        args.extend(["--focus", options.focus])
+    
     if options.threshold is not None:
         args.extend(["--threshold", str(options.threshold)])
     
-    if options.confidence is not None:
-        args.extend(["--confidence", str(options.confidence)])
+    if options.recommend:
+        args.append("--recommend")
     
-    if options.alpha is not None:
-        args.extend(["--alpha", str(options.alpha)])
+    if options.report:
+        args.extend(["--report", options.report])
     
-    if options.verbose:
-        args.append("--verbose")
+    if options.consistency_check:
+        args.append("--consistency-check")
     
-    if options.optimize:
-        args.append("--optimize")
+    if options.cross_validation:
+        args.append("--cross-validation")
+    
+    if options.confidence_level is not None:
+        args.extend(["--confidence-level", str(options.confidence_level)])
+    
+    if options.purpose:
+        args.extend(["--purpose", options.purpose])
     
-    if options.international:
-        args.append("--international")
+    # Advanced options
+    if options.alpha is not None:
+        args.extend(["--alpha", str(options.alpha)])
     
     if options.time_series:
         args.append("--time-series")