@voodocs/cli 2.5.2 → 3.0.0

package/lib/darkarts/validation/semantic.py

@@ -148,20 +148,42 @@ class ImportExtractor(ast.NodeVisitor):
 
 def extract_imports(file_path: Path) -> Set[str]:
     """
-    Extract all imports from a Python file using AST parsing.
+    Extract all imports from a source file.
     
-    Handles both absolute and relative imports.
+    Supports:
+    - Python: AST-based parsing
+    - TypeScript/JavaScript: Regex-based extraction
+    - Other languages: Best-effort regex extraction
     
     Args:
-        file_path: Path to the Python file
+        file_path: Path to the source file
     
     Returns:
-        Set of top-level module names imported in the file
+        Set of top-level module/package names imported in the file
     
     Examples:
         >>> extract_imports(Path("myfile.py"))
         {'os', 'sys', 'pathlib', 'typing', 'darkarts'}
+        >>> extract_imports(Path("myfile.ts"))
+        {'react', 'axios', './utils'}
     """
+    suffix = file_path.suffix.lower()
+    
+    # Python files - use AST parsing
+    if suffix == '.py':
+        return _extract_python_imports(file_path)
+    
+    # TypeScript/JavaScript files - use regex
+    elif suffix in {'.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'}:
+        return _extract_js_imports(file_path)
+    
+    # Other languages - best effort
+    else:
+        return _extract_generic_imports(file_path)
+
+
+def _extract_python_imports(file_path: Path) -> Set[str]:
+    """Extract imports from Python files using AST."""
     try:
         content = file_path.read_text(encoding='utf-8')
         tree = ast.parse(content, filename=str(file_path))
@@ -171,15 +193,13 @@ def extract_imports(file_path: Path) -> Set[str]:
         
         imports = extractor.get_all_imports()
         
-        # Filter out standard library modules that are commonly omitted
-        # from annotations (optional - can be configured)
+        # Filter out standard library modules
         stdlib_to_keep = {
             'typing', 'dataclasses', 'enum', 'abc', 'pathlib',
             'datetime', 'json', 'yaml', 're', 'os', 'sys',
             'time', 'uuid', 'collections', 'itertools', 'functools'
         }
         
-        # Keep all non-stdlib and explicitly listed stdlib modules
         filtered_imports = {
             imp for imp in imports
             if not _is_stdlib_module(imp) or imp in stdlib_to_keep
@@ -193,6 +213,69 @@ def extract_imports(file_path: Path) -> Set[str]:
         raise ValueError(f"Error parsing {file_path}: {e}")
 
 
+def _extract_js_imports(file_path: Path) -> Set[str]:
+    """Extract imports from TypeScript/JavaScript files using regex."""
+    try:
+        content = file_path.read_text(encoding='utf-8')
+        imports = set()
+        
+        # Match: import ... from 'module'
+        # Match: import ... from "module"
+        import_pattern = r"import\s+(?:.*?\s+from\s+)?['\"]([^'\"]+)['\"]"
+        for match in re.finditer(import_pattern, content):
+            module = match.group(1)
+            # Extract package name (ignore relative paths for now)
+            if not module.startswith('.'):
+                # Get first part of scoped package (@org/pkg) or regular package
+                if module.startswith('@'):
+                    parts = module.split('/')
+                    if len(parts) >= 2:
+                        imports.add(f"{parts[0]}/{parts[1]}")
+                else:
+                    imports.add(module.split('/')[0])
+        
+        # Match: require('module')
+        require_pattern = r"require\(['\"]([^'\"]+)['\"]\)"
+        for match in re.finditer(require_pattern, content):
+            module = match.group(1)
+            if not module.startswith('.'):
+                if module.startswith('@'):
+                    parts = module.split('/')
+                    if len(parts) >= 2:
+                        imports.add(f"{parts[0]}/{parts[1]}")
+                else:
+                    imports.add(module.split('/')[0])
+        
+        return imports
+    
+    except Exception as e:
+        raise ValueError(f"Error parsing {file_path}: {e}")
+
+
+def _extract_generic_imports(file_path: Path) -> Set[str]:
+    """Best-effort import extraction for other languages."""
+    try:
+        content = file_path.read_text(encoding='utf-8')
+        imports = set()
+        
+        # Generic patterns for various languages
+        patterns = [
+            r"import\s+['\"]([^'\"]+)['\"]",  # Generic import
+            r"require\(['\"]([^'\"]+)['\"]\)",  # Require
+            r"use\s+([\w:]+)",  # Rust/Perl
+            r"#include\s+[<\"]([^>\"]+)[>\"]"  # C/C++
+        ]
+        
+        for pattern in patterns:
+            for match in re.finditer(pattern, content):
+                imports.add(match.group(1))
+        
+        return imports
+    
+    except Exception as e:
+        return set()  # Return empty set on error for generic extraction
+
+
 def _is_stdlib_module(module_name: str) -> bool:
     """
     Check if a module is part of Python's standard library.
@@ -258,10 +341,15 @@ def parse_dependencies(annotation: str) -> Set[str]:
 
 def extract_annotation(file_path: Path) -> Optional[str]:
     """
-    Extract the @darkarts annotation from a Python file.
+    Extract the @darkarts annotation from any source file.
+    
+    Supports:
+    - Python: triple-quote @darkarts docstrings
+    - TypeScript/JavaScript: /**@darkarts ... */ block comments
+    - Other languages with similar comment syntax
     
     Args:
-        file_path: Path to the Python file
+        file_path: Path to the source file
     
     Returns:
         The annotation string, or None if not found
@@ -269,17 +357,46 @@ def extract_annotation(file_path: Path) -> Optional[str]:
     try:
         content = file_path.read_text(encoding='utf-8')
         
-        # Check if file starts with @darkarts annotation
-        if not content.startswith('"""@darkarts'):
-            return None
+        # Python-style docstring
+        if '"""@darkarts' in content:
+            start_idx = content.find('"""@darkarts')
+            end_idx = content.find('"""', start_idx + 3)
+            if end_idx != -1:
+                return content[start_idx + 3:end_idx]
+        
+        # JavaScript/TypeScript/C-style block comment
+        if '/**@darkarts' in content or '/*@darkarts' in content:
+            # Find the @darkarts comment
+            start_marker = '/**@darkarts' if '/**@darkarts' in content else '/*@darkarts'
+            start_idx = content.find(start_marker)
+            end_idx = content.find('*/', start_idx)
+            if end_idx != -1:
+                annotation = content[start_idx + len(start_marker):end_idx]
+                return annotation.strip()
         
-        # Find the end of the docstring
-        end_idx = content.find('"""', 3)
-        if end_idx == -1:
-            return None
+        # Single-line comment style (less common but supported)
+        if '//@darkarts' in content or '#@darkarts' in content:
+            lines = content.split('\n')
+            annotation_lines = []
+            in_annotation = False
+            for line in lines:
+                if '//@darkarts' in line or '#@darkarts' in line:
+                    in_annotation = True
+                    # Extract content after @darkarts
+                    if '//@darkarts' in line:
+                        annotation_lines.append(line.split('//@darkarts', 1)[1].strip())
+                    else:
+                        annotation_lines.append(line.split('#@darkarts', 1)[1].strip())
+                elif in_annotation and (line.strip().startswith('//') or line.strip().startswith('#')):
+                    # Continue multi-line annotation
+                    annotation_lines.append(line.strip().lstrip('/#').strip())
+                elif in_annotation:
+                    # End of annotation
+                    break
+            if annotation_lines:
+                return '\n'.join(annotation_lines)
         
-        annotation = content[3:end_idx]  # Skip opening """
-        return annotation
+        return None
     
     except Exception as e:
         raise ValueError(f"Error reading {file_path}: {e}")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voodocs/cli",
-  "version": "2.5.2",
+  "version": "3.0.0",
   "description": "AI-Native Symbolic Documentation System - The world's first documentation tool using mathematical notation with semantic validation",
   "main": "voodocs_cli.py",
   "bin": {
@@ -64,9 +64,10 @@
     "lib/darkarts/exceptions.py",
     "lib/darkarts/telemetry.py",
     "lib/darkarts/companion_files.py",
-    "lib/darkarts/voodocs_lite_dict.py",
-    "lib/darkarts/voodocs_lite_dict_v2.py",
-    "lib/darkarts/voodocs_lite_parser.py",
+    "lib/darkarts/darkarts_abbreviations.py",
+    "lib/darkarts/darkarts_patterns.py",
+    "lib/darkarts/darkarts_symbols.py",
+    "lib/darkarts/darkarts_parser_v3.py",
     "lib/darkarts/priority_analyzer/",
     "lib/darkarts/parsers/typescript/dist/",
     "lib/darkarts/parsers/typescript/src/",

package/lib/cli/convert.py

@@ -1,131 +0,0 @@
-"""@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)

package/lib/darkarts/voodocs_lite_dict.py

@@ -1,216 +0,0 @@
-"""
-VooDocs Lite - Abbreviation Dictionary
-
-Provides bidirectional mapping between full words and abbreviations
-for ultra-compact symbolic notation.
-"""
-
-# Abbreviation dictionary: abbr -> full
-ABBREVIATIONS = {
-    # Storage & Data
-    'db': 'database',
-    'cfg': 'configuration',
-    'var': 'variable',
-    'const': 'constant',
-    'param': 'parameter',
-    'arg': 'argument',
-    'id': 'identifier',
-    
-    # Common verbs
-    'must': 'must',
-    'be': 'be',
-    'is': 'is',
-    'are': 'are',
-    'has': 'has',
-    'have': 'have',
-    'does': 'does',
-    'do': 'do',
-    'will': 'will',
-    'can': 'can',
-    'should': 'should',
-    'may': 'may',
-    'contains': 'contains',
-    'returns': 'returns',
-    'expire': 'expire',
-    'expires': 'expires',
-    'stored': 'stored',
-    'signed': 'signed',
-    'hashed': 'hashed',
-    'valid': 'valid',
-    'logged': 'logged',
-    
-    # Actions
-    'init': 'initialize',
-    'val': 'validate',
-    'ver': 'verify',
-    'gen': 'generate',
-    'cr': 'create',
-    'upd': 'update',
-    'del': 'delete',
-    'mod': 'modify',
-    'get': 'retrieve',
-    'qry': 'query',
-    'chk': 'check',
-    
-    # Security
-    'auth': 'authentication',
-    'authz': 'authorization',
-    'pwd': 'password',
-    'tok': 'token',
-    
-    # Entities
-    'usr': 'user',
-    'usrs': 'users',
-    
-    # Time
-    'ts': 'timestamp',
-    'exp': 'expiration',
-    
-    # Communication
-    'resp': 'response',
-    'req': 'request',
-    'msg': 'message',
-    
-    # Status & Errors
-    'err': 'error',
-    'exc': 'exception',
-    'ok': 'success',
-    'fail': 'failure',
-    
-    # Boolean & Values
-    'T': 'true',
-    'F': 'false',
-    'N': 'null',
-    'U': 'undefined',
-    'E': 'empty',
-    
-    # Types
-    'str': 'string',
-    'num': 'number',
-    'int': 'integer',
-    'bool': 'boolean',
-    'arr': 'array',
-    'obj': 'object',
-    'fn': 'function',
-    
-    # Blockchain
-    'addr': 'address',
-    'ctr': 'contract',
-    'tx': 'transaction',
-    'blk': 'block',
-    'bal': 'balance',
-    'amt': 'amount',
-    
-    # Domain-specific
-    'sub': 'subdomain',
-    'subs': 'subdomains',
-    'reg': 'registry',
-    'own': 'owner',
-    'mgmt': 'management',
-    
-    # Common words
-    'w/': 'with',
-    'wo/': 'without',
-    'svc': 'service',
-    'sys': 'system',
-    'ops': 'operations',
-    'ret': 'returns',
-    'res': 'result',
-    'val': 'value',
-    'vals': 'values',
-    'len': 'length',
-    'cnt': 'count',
-    'max': 'maximum',
-    'min': 'minimum',
-    'avg': 'average',
-    'sum': 'summary',
-    'desc': 'description',
-    'info': 'information',
-    'spec': 'specification',
-    'impl': 'implementation',
-    'ref': 'reference',
-    'def': 'definition',
-    'decl': 'declaration',
-}
-
-# Reverse mapping: full -> abbr
-EXPANSIONS = {v: k for k, v in ABBREVIATIONS.items()}
-
-# Symbol mappings
-LITE_TO_STANDARD = {
-    '>': '⊢',  # Purpose/Postcondition (context-dependent)
-    '@': '∂',  # Dependencies
-    '!': '⚠',  # Assumptions
-    '<': '⊳',  # Preconditions
-    '=': '⊨',  # Invariants
-    '~': '⚡',  # Complexity
-    '#': '🔒',  # Security
-}
-
-STANDARD_TO_LITE = {v: k for k, v in LITE_TO_STANDARD.items()}
-
-
-def expand_abbreviation(abbr: str) -> str:
-    """Expand an abbreviation to its full form."""
-    return ABBREVIATIONS.get(abbr, abbr)
-
-
-def compress_word(word: str) -> str:
-    """Compress a word to its abbreviation."""
-    return EXPANSIONS.get(word.lower(), word)
-
-
-def expand_text(text: str) -> str:
-    """
-    Expand abbreviated text to full form.
-    
-    Example:
-        "usr auth svc w/ JWT gen" -> "user authentication service with JWT generation"
-    """
-    words = text.split()
-    expanded = []
-    
-    for word in words:
-        # Check if word has punctuation
-        if word[-1] in '.,;:!?':
-            punct = word[-1]
-            word_part = word[:-1]
-            expanded_word = expand_abbreviation(word_part)
-            expanded.append(expanded_word + punct)
-        else:
-            expanded.append(expand_abbreviation(word))
-    
-    return ' '.join(expanded)
-
-
-def compress_text(text: str) -> str:
-    """
-    Compress text using abbreviations.
-    
-    Example:
-        "user authentication service with JWT generation" -> "usr auth svc w/ JWT gen"
-    """
-    words = text.split()
-    compressed = []
-    
-    for word in words:
-        # Check if word has punctuation
-        if word[-1] in '.,;:!?':
-            punct = word[-1]
-            word_part = word[:-1]
-            compressed_word = compress_word(word_part)
-            compressed.append(compressed_word + punct)
-        else:
-            compressed.append(compress_word(word))
-    
-    return ' '.join(compressed)
-
-
-def get_lite_symbol(standard_symbol: str) -> str:
-    """Convert standard VooDocs symbol to Lite symbol."""
-    return STANDARD_TO_LITE.get(standard_symbol, standard_symbol)
-
-
-def get_standard_symbol(lite_symbol: str) -> str:
-    """Convert Lite symbol to standard VooDocs symbol."""
-    return LITE_TO_STANDARD.get(lite_symbol, lite_symbol)