@voodocs/cli 0.4.1 → 0.4.2

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.4.2] - 2024-12-20
+
+### Fixed
+- **npm package**: Added missing `cli_darkarts.py` to package files list
+  - Fixes "ModuleNotFoundError: No module named 'darkarts.cli_darkarts'" error
+  - DarkArts CLI commands now work correctly after npm install
+  - No code changes, only packaging fix
+
+---
+
 ## [0.4.1] - 2024-12-20
 
 ### Fixed

package/lib/darkarts/cli_darkarts.py

@@ -0,0 +1,385 @@
+"""@darkarts
+⊢cli:darkarts.commands
+∂{argparse,pathlib,annotations}
+⚠{files-exist,valid-paths}
+⊨{∀cmd→exit∈{0,1},user-friendly-errors}
+🔒{read-write-files}
+⚡{O(n)|n=files}
+
+DarkArts CLI Commands
+
+Provides CLI commands for DarkArts symbolic documentation.
+"""
+
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from darkarts.annotations import (
+    parse_darkarts,
+    DarkArtsParser,
+    DarkArtsTranslator,
+    convert_voodocs_to_darkarts,
+)
+from darkarts.annotations.parser import AnnotationParser
+
+
+def cmd_darkarts_translate(args):
+    """
+    Translate DarkArts annotations to natural language or vice versa.
+    
+    Usage:
+        voodocs darkarts translate <files> [--to-symbols]
+    """
+    print("🔮 DarkArts Translation")
+    print("=" * 60)
+    print()
+    
+    translator = DarkArtsTranslator()
+    to_symbols = args.to_symbols if hasattr(args, 'to_symbols') else False
+    
+    for file_path in args.files:
+        path = Path(file_path)
+        
+        if not path.exists():
+            print(f"❌ File not found: {file_path}")
+            continue
+        
+        print(f"📄 {path.name}")
+        print("-" * 60)
+        
+        try:
+            if to_symbols:
+                # Natural language → Symbols (VooDocs → DarkArts)
+                parser = AnnotationParser()
+                annotations = parser.parse_file(str(path))
+                
+                if annotations.module:
+                    # Convert module annotation
+                    voodocs_dict = {
+                        'module_purpose': annotations.module.module_purpose,
+                        'dependencies': annotations.module.dependencies,
+                        'assumptions': annotations.module.assumptions,
+                    }
+                    
+                    darkarts = convert_voodocs_to_darkarts(voodocs_dict)
+                    print(darkarts)
+                else:
+                    print("⚠️  No @voodocs annotations found")
+            else:
+                # Symbols → Natural language (DarkArts → Human)
+                darkarts_annotations = parse_darkarts(path.read_text())
+                
+                if darkarts_annotations:
+                    for i, ann in enumerate(darkarts_annotations, 1):
+                        if len(darkarts_annotations) > 1:
+                            print(f"\n## Annotation {i}\n")
+                        natural = translator.symbols_to_natural(ann)
+                        print(natural)
+                else:
+                    print("⚠️  No @darkarts annotations found")
+        
+        except Exception as e:
+            print(f"❌ Error: {e}")
+        
+        print()
+    
+    return 0
+
+
+def cmd_darkarts_convert(args):
+    """
+    Convert files between VooDocs and DarkArts formats.
+    
+    Usage:
+        voodocs darkarts convert <files> [--in-place]
+    """
+    print("🔄 DarkArts Conversion")
+    print("=" * 60)
+    print()
+    
+    translator = DarkArtsTranslator()
+    in_place = args.in_place if hasattr(args, 'in_place') else False
+    
+    for file_path in args.files:
+        path = Path(file_path)
+        
+        if not path.exists():
+            print(f"❌ File not found: {file_path}")
+            continue
+        
+        print(f"📄 {path.name}")
+        
+        try:
+            content = path.read_text()
+            
+            # Parse VooDocs annotations
+            parser = AnnotationParser()
+            annotations = parser.parse_file(str(path))
+            
+            if not annotations.module:
+                print("  ⚠️  No @voodocs annotations found")
+                continue
+            
+            # Convert to DarkArts
+            voodocs_dict = {
+                'module_purpose': annotations.module.module_purpose,
+                'dependencies': annotations.module.dependencies,
+                'assumptions': annotations.module.assumptions,
+            }
+            
+            darkarts = convert_voodocs_to_darkarts(voodocs_dict)
+            
+            if in_place:
+                # Replace @voodocs with @darkarts in file
+                # This is a simple replacement - in production would be more sophisticated
+                new_content = content.replace(
+                    '"""@voodocs',
+                    darkarts.replace('"""@darkarts\n', '').replace('\n"""', '')
+                )
+                path.write_text(new_content)
+                print("  ✅ Converted in place")
+            else:
+                # Print to console
+                print(darkarts)
+        
+        except Exception as e:
+            print(f"  ❌ Error: {e}")
+        
+        print()
+    
+    return 0
+
+
+def cmd_darkarts_stats(args):
+    """
+    Show statistics about DarkArts annotations.
+    
+    Usage:
+        voodocs darkarts stats <paths>
+    """
+    print("📊 DarkArts Statistics")
+    print("=" * 60)
+    print()
+    
+    total_files = 0
+    files_with_darkarts = 0
+    total_annotations = 0
+    total_symbols = 0
+    symbol_counts = {}
+    
+    paths = args.paths if hasattr(args, 'paths') else ['.']
+    
+    for path_str in paths:
+        path = Path(path_str)
+        
+        if path.is_file():
+            files = [path]
+        elif path.is_dir():
+            files = list(path.rglob('*.py'))
+        else:
+            continue
+        
+        for file_path in files:
+            total_files += 1
+            
+            try:
+                content = file_path.read_text()
+                annotations = parse_darkarts(content)
+                
+                if annotations:
+                    files_with_darkarts += 1
+                    total_annotations += len(annotations)
+                    
+                    # Count symbols
+                    for ann in annotations:
+                        for char in ann.raw_text:
+                            if char in ['⊢', '∂', '⚠', '⊨', '🔒', '⚡', '∀', '∃', '∧', '∨', '¬', '⇒', '∈']:
+                                symbol_counts[char] = symbol_counts.get(char, 0) + 1
+                                total_symbols += 1
+            
+            except Exception:
+                pass
+    
+    # Print statistics
+    print(f"Total files scanned: {total_files}")
+    print(f"Files with @darkarts: {files_with_darkarts}")
+    print(f"Total annotations: {total_annotations}")
+    print(f"Total symbols used: {total_symbols}")
+    
+    if symbol_counts:
+        print("\nMost used symbols:")
+        sorted_symbols = sorted(symbol_counts.items(), key=lambda x: x[1], reverse=True)
+        for symbol, count in sorted_symbols[:10]:
+            print(f"  {symbol} : {count}")
+    
+    if total_files > 0:
+        coverage = (files_with_darkarts / total_files) * 100
+        print(f"\nCoverage: {coverage:.1f}%")
+    
+    print()
+    return 0
+
+
+def cmd_darkarts_validate(args):
+    """
+    Validate DarkArts annotations.
+    
+    Usage:
+        voodocs darkarts validate <files>
+    """
+    print("✅ DarkArts Validation")
+    print("=" * 60)
+    print()
+    
+    all_valid = True
+    
+    for file_path in args.files:
+        path = Path(file_path)
+        
+        if not path.exists():
+            print(f"❌ File not found: {file_path}")
+            all_valid = False
+            continue
+        
+        print(f"📄 {path.name}")
+        
+        try:
+            content = path.read_text()
+            annotations = parse_darkarts(content)
+            
+            if not annotations:
+                print("  ⚠️  No @darkarts annotations found")
+                continue
+            
+            for i, ann in enumerate(annotations, 1):
+                # Basic validation
+                issues = []
+                
+                if not ann.module:
+                    issues.append("Missing module declaration (⊢)")
+                
+                if not ann.dependencies:
+                    issues.append("Missing dependencies (∂)")
+                
+                if not ann.invariants:
+                    issues.append("Missing invariants (⊨)")
+                
+                if issues:
+                    print(f"  ⚠️  Annotation {i}:")
+                    for issue in issues:
+                        print(f"     - {issue}")
+                    all_valid = False
+                else:
+                    print(f"  ✅ Annotation {i}: Valid")
+        
+        except Exception as e:
+            print(f"  ❌ Error: {e}")
+            all_valid = False
+        
+        print()
+    
+    return 0 if all_valid else 1
+
+
+def add_darkarts_subcommands(subparsers):
+    """
+    Add DarkArts subcommands to VooDocs CLI.
+    
+    Args:
+        subparsers: Argparse subparsers object
+    """
+    # darkarts command group
+    darkarts_parser = subparsers.add_parser(
+        "darkarts",
+        help="DarkArts symbolic documentation tools"
+    )
+    darkarts_subparsers = darkarts_parser.add_subparsers(
+        dest="darkarts_action",
+        help="DarkArts actions"
+    )
+    
+    # darkarts translate
+    translate_parser = darkarts_subparsers.add_parser(
+        "translate",
+        help="Translate between symbols and natural language"
+    )
+    translate_parser.add_argument(
+        "files",
+        nargs="+",
+        help="Files to translate"
+    )
+    translate_parser.add_argument(
+        "--to-symbols",
+        action="store_true",
+        help="Translate from natural language to symbols (default: symbols to natural)"
+    )
+    
+    # darkarts convert
+    convert_parser = darkarts_subparsers.add_parser(
+        "convert",
+        help="Convert VooDocs annotations to DarkArts"
+    )
+    convert_parser.add_argument(
+        "files",
+        nargs="+",
+        help="Files to convert"
+    )
+    convert_parser.add_argument(
+        "--in-place",
+        action="store_true",
+        help="Modify files in place (default: print to console)"
+    )
+    
+    # darkarts stats
+    stats_parser = darkarts_subparsers.add_parser(
+        "stats",
+        help="Show DarkArts usage statistics"
+    )
+    stats_parser.add_argument(
+        "paths",
+        nargs="*",
+        default=["."],
+        help="Paths to analyze (default: current directory)"
+    )
+    
+    # darkarts validate
+    validate_parser = darkarts_subparsers.add_parser(
+        "validate",
+        help="Validate DarkArts annotations"
+    )
+    validate_parser.add_argument(
+        "files",
+        nargs="+",
+        help="Files to validate"
+    )
+    
+    return darkarts_parser
+
+
+def dispatch_darkarts_command(args):
+    """
+    Dispatch DarkArts subcommands.
+    
+    Args:
+        args: Parsed command-line arguments
+        
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    if not hasattr(args, 'darkarts_action') or not args.darkarts_action:
+        print("Error: No DarkArts action specified")
+        print("Use 'voodocs darkarts --help' for usage")
+        return 1
+    
+    if args.darkarts_action == "translate":
+        return cmd_darkarts_translate(args)
+    elif args.darkarts_action == "convert":
+        return cmd_darkarts_convert(args)
+    elif args.darkarts_action == "stats":
+        return cmd_darkarts_stats(args)
+    elif args.darkarts_action == "validate":
+        return cmd_darkarts_validate(args)
+    else:
+        print(f"Error: Unknown DarkArts action: {args.darkarts_action}")
+        return 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voodocs/cli",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "AI-Native Documentation System - Generate docs, tests, and API specs from @voodocs annotations using the DarkArts language",
   "main": "cli.py",
   "bin": {
@@ -45,6 +45,7 @@
   "devDependencies": {},
   "files": [
     "cli.py",
+    "lib/darkarts/cli_darkarts.py",
     "lib/darkarts/annotations/",
     "lib/darkarts/context/",
     "lib/darkarts/core/",