@voodocs/cli 2.5.0 → 2.5.2

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # CHANGELOG
 
+## [2.5.2] - 2024-12-24
+
+### Fixed
+- **CLI Registration**: Fixed analyze, convert, and companion commands not being registered
+  - Converted `analyze.py` from argparse to Click command
+  - Created `convert.py` as Click command for VooDocs Lite conversion
+  - Updated `lib/cli/__init__.py` to import and register all three commands
+  - Updated `__version__` from "2.1.3" to "2.5.2" in Python code
+- v2.5.0 and v2.5.1 had files in package but commands weren't accessible via CLI
+- All Priority Analyzer and VooDocs Lite features now fully functional
+
+---
+
+## [2.5.1] - 2024-12-24
+
+### Fixed
+- **Packaging Issue**: Fixed npm package to include missing files from v2.5.0
+  - Added `lib/darkarts/priority_analyzer/` directory
+  - Added `lib/darkarts/voodocs_lite_dict.py`
+  - Added `lib/darkarts/voodocs_lite_dict_v2.py`
+  - Added `lib/darkarts/voodocs_lite_parser.py`
+- v2.5.0 was published with CHANGELOG updates but missing actual code files
+- All Priority Analyzer and VooDocs Lite features now properly included
+
+---
+
 ## [2.5.0] - 2024-12-24
 
 ### Added

package/lib/cli/__init__.py

@@ -16,7 +16,7 @@ This module provides the command-line interface for VooDocs.
 import click
 from typing import Optional
 
-__version__ = "2.1.3"
+__version__ = "2.5.2"
 
 
 @click.group()
@@ -41,6 +41,9 @@ from .generate import generate
 from .benchmark import benchmark
 from .fix import fix
 from .context import context
+from .analyze import analyze
+from .convert import convert
+from .companion import companion
 
 # Register commands
 cli.add_command(init)
@@ -50,6 +53,9 @@ cli.add_command(generate)
 cli.add_command(benchmark)
 cli.add_command(fix)
 cli.add_command(context)
+cli.add_command(analyze)
+cli.add_command(convert)
+cli.add_command(companion)
 
 
 def main():

package/lib/cli/analyze.py

@@ -1,29 +1,96 @@
+"""@darkarts
+⊢cli:analyze
+∂{click,pathlib,darkarts.priority_analyzer}
+⚠{python≥3.7,click≥8.0}
+⊨{∀file→analyzed,∀score→calculated}
+🔒{read-only:source-files}
+⚡{O(n):files}
 """
-CLI command for VooDocs Priority Analyzer
 
-Usage: voodocs analyze [path] [options]
 """
+VooDocs Analyze Command
 
+Analyze files to identify which need VooDocs annotations most urgently.
+"""
+
+import click
 import os
 import sys
+import json
+import csv
 from pathlib import Path
 
 # Add parent directory to path for imports
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from darkarts.priority_analyzer.analyzer import PriorityAnalyzer
 
-from lib.darkarts.priority_analyzer.analyzer import PriorityAnalyzer
 
-
-def cmd_analyze(args):
-    """Execute the analyze command."""
-    # Get path (default to current directory)
-    path = args.path if hasattr(args, 'path') and args.path else '.'
+@click.command()
+@click.argument(
+    'path',
+    type=click.Path(exists=True),
+    default='.',
+    required=False
+)
+@click.option(
+    '-r', '--recursive',
+    is_flag=True,
+    default=True,
+    help='Recursively analyze directories (default: true)'
+)
+@click.option(
+    '--top',
+    type=int,
+    default=10,
+    help='Show top N files (default: 10, 0 for all)'
+)
+@click.option(
+    '--priority',
+    type=click.Choice(['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'MINIMAL'], case_sensitive=False),
+    help='Filter by priority level'
+)
+@click.option(
+    '--min-score',
+    type=int,
+    help='Minimum priority score to show'
+)
+@click.option(
+    '--format',
+    'output_format',
+    type=click.Choice(['text', 'json', 'csv', 'markdown']),
+    default='text',
+    help='Output format (default: text)'
+)
+@click.option(
+    '--include-annotated',
+    is_flag=True,
+    help='Include fully annotated files'
+)
+@click.option(
+    '--exclude',
+    help='Comma-separated list of patterns to exclude'
+)
+def analyze(path, recursive, top, priority, min_score, output_format, include_annotated, exclude):
+    """
+    Analyze files to identify which need VooDocs annotations most urgently.
+    
+    Uses heuristics based on:
+    - File complexity (LOC, cyclomatic complexity, function count)
+    - Security keywords (auth, password, token, etc.)
+    - Import/dependency count
+    
+    Examples:
+        voodocs analyze src/
+        voodocs analyze src/ --top 20
+        voodocs analyze src/ --priority critical
+        voodocs analyze src/ --format json
+    """
     path = os.path.abspath(path)
     
     # Check if path exists
     if not os.path.exists(path):
-        print(f"❌ Error: Path not found: {path}")
-        return 1
+        click.echo(f"❌ Error: Path not found: {path}", err=True)
+        sys.exit(1)
     
     # Determine if path is file or directory
     is_file = os.path.isfile(path)
@@ -36,38 +103,34 @@ def cmd_analyze(args):
     if is_file:
         scores = [analyzer.analyze_file(path)]
     else:
-        recursive = getattr(args, 'recursive', True)
-        exclude = getattr(args, 'exclude', None)
         exclude_patterns = exclude.split(',') if exclude else None
         
-        print(f"🔍 Analyzing files in: {path}")
-        if recursive:
-            print("   (recursive mode)")
-        print()
+        if output_format == 'text':
+            click.echo(f"🔍 Analyzing files in: {path}")
+            if recursive:
+                click.echo("   (recursive mode)")
+            click.echo()
         
         scores = analyzer.analyze_directory(path, recursive, exclude_patterns)
     
     # Filter by priority level if specified
-    if hasattr(args, 'priority') and args.priority:
-        priority_filter = args.priority.upper()
+    if priority:
+        priority_filter = priority.upper()
         scores = [s for s in scores if s.priority_level == priority_filter]
     
     # Filter by minimum score
-    if hasattr(args, 'min_score') and args.min_score:
-        scores = [s for s in scores if s.priority_score >= args.min_score]
+    if min_score:
+        scores = [s for s in scores if s.priority_score >= min_score]
     
     # Filter out fully annotated files (unless --include-annotated)
-    if not getattr(args, 'include_annotated', False):
+    if not include_annotated:
         scores = [s for s in scores if s.annotation_coverage < 1.0]
     
     # Limit to top N
-    top_n = getattr(args, 'top', 10)
-    if top_n and top_n > 0:
-        scores = scores[:top_n]
-    
-    # Output format
-    output_format = getattr(args, 'format', 'text')
+    if top and top > 0:
+        scores = scores[:top]
     
+    # Output
     if output_format == 'json':
         _output_json(scores)
     elif output_format == 'csv':
@@ -77,14 +140,14 @@ def cmd_analyze(args):
     else:
         _output_text(scores, path)
     
-    return 0
+    sys.exit(0)
 
 
 def _output_text(scores, path):
     """Output results in human-readable text format."""
     if not scores:
-        print("✅ No files need annotations!")
-        print("   All files are either fully annotated or below priority threshold.")
+        click.echo("✅ No files need annotations!")
+        click.echo("   All files are either fully annotated or below priority threshold.")
         return
     
     # Calculate statistics
@@ -101,34 +164,34 @@ def _output_text(scores, path):
     coverage_pct = (annotated_count / total_files * 100) if total_files > 0 else 0
     
     # Header
-    print("━" * 70)
-    print("VooDocs Priority Analysis")
-    print("━" * 70)
-    print()
-    print(f"Project: {path}")
-    print(f"Files analyzed: {total_files}")
-    print(f"Annotations found: {annotated_count} ({coverage_pct:.0f}% coverage)")
-    print()
+    click.echo("━" * 70)
+    click.echo("VooDocs Priority Analysis")
+    click.echo("━" * 70)
+    click.echo()
+    click.echo(f"Project: {path}")
+    click.echo(f"Files analyzed: {total_files}")
+    click.echo(f"Annotations found: {annotated_count} ({coverage_pct:.0f}% coverage)")
+    click.echo()
     
     # Priority distribution
-    print("Priority Distribution:")
+    click.echo("Priority Distribution:")
     if priority_dist['CRITICAL'] > 0:
-        print(f"🔴 CRITICAL (80-100): {priority_dist['CRITICAL']} files")
+        click.echo(f"🔴 CRITICAL (80-100): {priority_dist['CRITICAL']} files")
     if priority_dist['HIGH'] > 0:
-        print(f"🟠 HIGH (60-79):     {priority_dist['HIGH']} files")
+        click.echo(f"🟠 HIGH (60-79):     {priority_dist['HIGH']} files")
     if priority_dist['MEDIUM'] > 0:
-        print(f"🟡 MEDIUM (40-59):   {priority_dist['MEDIUM']} files")
+        click.echo(f"🟡 MEDIUM (40-59):   {priority_dist['MEDIUM']} files")
     if priority_dist['LOW'] > 0:
-        print(f"🟢 LOW (20-39):      {priority_dist['LOW']} files")
+        click.echo(f"🟢 LOW (20-39):      {priority_dist['LOW']} files")
     if priority_dist['MINIMAL'] > 0:
-        print(f"⚪ MINIMAL (0-19):    {priority_dist['MINIMAL']} files")
-    print()
+        click.echo(f"⚪ MINIMAL (0-19):    {priority_dist['MINIMAL']} files")
+    click.echo()
     
     # Top files
-    print("━" * 70)
-    print(f"Top {len(scores)} Files Needing Annotations")
-    print("━" * 70)
-    print()
+    click.echo("━" * 70)
+    click.echo(f"Top {len(scores)} Files Needing Annotations")
+    click.echo("━" * 70)
+    click.echo()
     
     for i, score in enumerate(scores, 1):
         # Priority emoji
@@ -143,41 +206,39 @@ def _output_text(scores, path):
         # Relative path
         rel_path = os.path.relpath(score.filepath, path) if not os.path.isfile(path) else score.filepath
         
-        print(f"{i}. {emoji} {rel_path} (Score: {score.priority_score:.0f})")
-        print(f"   Complexity: {score.complexity_score}  Security: {score.security_score}  Dependencies: {score.dependency_score}  Annotations: {score.annotation_penalty}")
-        print()
+        click.echo(f"{i}. {emoji} {rel_path} (Score: {score.priority_score:.0f})")
+        click.echo(f"   Complexity: {score.complexity_score}  Security: {score.security_score}  Dependencies: {score.dependency_score}  Annotations: {score.annotation_penalty}")
+        click.echo()
         
         # Reasons
         if score.reasons:
-            print("   Reasons:")
+            click.echo("   Reasons:")
             for reason in score.reasons:
-                print(f"   • {reason}")
-            print()
+                click.echo(f"   • {reason}")
+            click.echo()
         
         # Suggestions
         if score.suggestions:
-            print("   Suggestions:")
+            click.echo("   Suggestions:")
             for suggestion in score.suggestions:
-                print(f"   ✓ {suggestion}")
-            print()
+                click.echo(f"   ✓ {suggestion}")
+            click.echo()
     
     # Footer
-    print("━" * 70)
-    print()
-    print("💡 Tip: Start with CRITICAL files first. Use:")
+    click.echo("━" * 70)
+    click.echo()
+    click.echo("💡 Tip: Start with CRITICAL files first. Use:")
     if scores:
         first_file = scores[0].filepath
-        print(f"   voodocs companion {first_file}")
-    print()
-    print("   Or convert to VooDocs Lite for faster annotation:")
-    print(f"   voodocs convert {path} --to lite --in-place")
-    print()
+        click.echo(f"   voodocs companion {first_file}")
+    click.echo()
+    click.echo("   Or convert to VooDocs Lite for faster annotation:")
+    click.echo(f"   voodocs convert {path} --to lite")
+    click.echo()
 
 
 def _output_json(scores):
     """Output results in JSON format."""
-    import json
-    
     data = []
     for score in scores:
         data.append({
@@ -197,14 +258,11 @@ def _output_json(scores):
             'suggestions': score.suggestions
         })
     
-    print(json.dumps(data, indent=2))
+    click.echo(json.dumps(data, indent=2))
 
 
 def _output_csv(scores):
     """Output results in CSV format."""
-    import csv
-    import sys
-    
     writer = csv.writer(sys.stdout)
     
     # Header
@@ -234,14 +292,14 @@ def _output_csv(scores):
 
 def _output_markdown(scores):
     """Output results in Markdown format."""
-    print("# VooDocs Priority Analysis")
-    print()
-    print("## Summary")
-    print()
-    print(f"- **Files analyzed:** {len(scores)}")
-    print()
-    print("## Top Files")
-    print()
+    click.echo("# VooDocs Priority Analysis")
+    click.echo()
+    click.echo("## Summary")
+    click.echo()
+    click.echo(f"- **Files analyzed:** {len(scores)}")
+    click.echo()
+    click.echo("## Top Files")
+    click.echo()
     
     for i, score in enumerate(scores, 1):
         emoji = {
@@ -252,26 +310,26 @@ def _output_markdown(scores):
             'MINIMAL': '⚪'
         }.get(score.priority_level, '⚪')
         
-        print(f"### {i}. {emoji} {score.filepath}")
-        print()
-        print(f"**Score:** {score.priority_score:.0f} ({score.priority_level})")
-        print()
-        print(f"- Complexity: {score.complexity_score}")
-        print(f"- Security: {score.security_score}")
-        print(f"- Dependencies: {score.dependency_score}")
-        print(f"- Annotation Coverage: {score.annotation_coverage * 100:.0f}%")
-        print()
+        click.echo(f"### {i}. {emoji} {score.filepath}")
+        click.echo()
+        click.echo(f"**Score:** {score.priority_score:.0f} ({score.priority_level})")
+        click.echo()
+        click.echo(f"- Complexity: {score.complexity_score}")
+        click.echo(f"- Security: {score.security_score}")
+        click.echo(f"- Dependencies: {score.dependency_score}")
+        click.echo(f"- Annotation Coverage: {score.annotation_coverage * 100:.0f}%")
+        click.echo()
         
         if score.reasons:
-            print("**Reasons:**")
-            print()
+            click.echo("**Reasons:**")
+            click.echo()
             for reason in score.reasons:
-                print(f"- {reason}")
-            print()
+                click.echo(f"- {reason}")
+            click.echo()
         
         if score.suggestions:
-            print("**Suggestions:**")
-            print()
+            click.echo("**Suggestions:**")
+            click.echo()
             for suggestion in score.suggestions:
-                print(f"- {suggestion}")
-            print()
+                click.echo(f"- {suggestion}")
+            click.echo()

package/lib/cli/convert.py

@@ -0,0 +1,131 @@
+"""@darkarts
+⊢cli:convert
+∂{click,pathlib,darkarts.voodocs_lite_parser}
+⚠{python≥3.7,click≥8.0}
+⊨{∀file→converted|skipped,∀error→reported}
+🔒{read-only:source-files}
+⚡{O(n):files}
+"""
+
+"""
+VooDocs Convert Command
+
+Convert VooDocs annotations between Standard and Lite formats.
+"""
+
+import click
+from pathlib import Path
+import sys
+
+# Import VooDocs Lite parser
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from darkarts.voodocs_lite_parser import VooDocsLiteParser
+
+
+@click.command()
+@click.argument(
+    'paths',
+    nargs=-1,
+    type=click.Path(exists=True),
+    required=True
+)
+@click.option(
+    '--to',
+    'target_format',
+    type=click.Choice(['lite', 'standard']),
+    required=True,
+    help='Target format to convert to'
+)
+@click.option(
+    '-r', '--recursive',
+    is_flag=True,
+    help='Recursively process directories'
+)
+@click.option(
+    '--dry-run',
+    is_flag=True,
+    help='Show what would be converted without modifying files'
+)
+@click.option(
+    '-v', '--verbose',
+    is_flag=True,
+    help='Show detailed conversion information'
+)
+def convert(paths, target_format, recursive, dry_run, verbose):
+    """
+    Convert VooDocs annotations between Standard and Lite formats.
+    
+    Examples:
+        voodocs convert src/ --to lite
+        voodocs convert src/ --to standard --recursive
+        voodocs convert file.ts --to lite --dry-run
+    """
+    parser = VooDocsLiteParser()
+    
+    converted_count = 0
+    skipped_count = 0
+    error_count = 0
+    
+    for path_str in paths:
+        path = Path(path_str)
+        
+        if path.is_file():
+            files = [path]
+        elif path.is_dir():
+            if recursive:
+                files = list(path.rglob('*.ts')) + list(path.rglob('*.js')) + \
+                       list(path.rglob('*.py')) + list(path.rglob('*.sol'))
+            else:
+                files = list(path.glob('*.ts')) + list(path.glob('*.js')) + \
+                       list(path.glob('*.py')) + list(path.glob('*.sol'))
+        else:
+            click.echo(f"❌ Invalid path: {path}", err=True)
+            error_count += 1
+            continue
+        
+        for file_path in files:
+            try:
+                # Read file
+                content = file_path.read_text()
+                
+                # Convert
+                if target_format == 'lite':
+                    converted = parser.standard_to_lite(content)
+                else:
+                    converted = parser.lite_to_standard(content)
+                
+                # Check if anything changed
+                if converted == content:
+                    if verbose:
+                        click.echo(f"⏭️  Skipped (no changes): {file_path}")
+                    skipped_count += 1
+                    continue
+                
+                # Write or show
+                if dry_run:
+                    click.echo(f"Would convert: {file_path}")
+                    if verbose:
+                        click.echo(f"  {len(content)} → {len(converted)} chars")
+                else:
+                    file_path.write_text(converted)
+                    click.echo(f"✅ Converted: {file_path}")
+                
+                converted_count += 1
+                
+            except Exception as e:
+                click.echo(f"❌ Error converting {file_path}: {e}", err=True)
+                error_count += 1
+    
+    # Summary
+    click.echo()
+    click.echo(f"Summary:")
+    click.echo(f"  ✅ Converted: {converted_count}")
+    click.echo(f"  ⏭️  Skipped: {skipped_count}")
+    if error_count > 0:
+        click.echo(f"  ❌ Errors: {error_count}")
+    
+    if dry_run:
+        click.echo()
+        click.echo("(Dry run - no files were modified)")
+    
+    sys.exit(0 if error_count == 0 else 1)