@voodocs/cli 1.0.6 → 2.0.0

package/lib/cli/init.py

@@ -1,8 +1,8 @@
 """@darkarts
-⊢{cli:init}
-∂{click,pathlib,json}
+⊢{cli:init-wizard}
+∂{click,pathlib,json,os,subprocess}
 ⚠{write-access:cwd}
-⊨{idempotent:config-creation}
+⊨{idempotent:config-creation,rerunnable:upgrade-support}
 🔒{read-write:filesystem}
 ⚡{O(1):file-creation}
 """
@@ -10,52 +10,250 @@
 """
 VooDocs Init Command
 
-Initialize a new project with VooDocs configuration and example annotations.
+Interactive wizard to initialize or upgrade a project with VooDocs.
+Re-runnable to add missing features after upgrades.
 """
 
 import click
 import json
+import os
+import subprocess
 from pathlib import Path
+from typing import Optional, Dict, Any
 
 
 @click.command()
 @click.option(
-    '--format',
-    type=click.Choice(['voodocs', 'darkarts'], case_sensitive=False),
-    default='voodocs',
-    help='Annotation format to use (voodocs or darkarts symbolic)'
+    '--non-interactive',
+    is_flag=True,
+    help='Skip interactive prompts and use defaults'
 )
 @click.option(
-    '--config-only',
+    '--upgrade',
     is_flag=True,
-    help='Only create configuration file, skip example files'
+    help='Upgrade existing configuration (add missing features)'
 )
-def init(format, config_only):
+def init(non_interactive, upgrade):
     """
-    Initialize a new project with VooDocs.
+    Initialize or upgrade a project with VooDocs.
+    
+    This interactive wizard will:
+    - Set up your project configuration
+    - Auto-detect project details (version, repository, AI environment)
+    - Create AI instructions for your coding assistant
+    - Configure privacy settings (.gitignore)
+    - Generate example annotated files
     
-    Creates a .voodocs.json configuration file and optionally generates
-    example annotated files to help you get started.
+    Re-run after upgrading to add new features!
     
     Examples:
-        voodocs init                    # Initialize with @voodocs format
-        voodocs init --format darkarts  # Initialize with symbolic @darkarts format
-        voodocs init --config-only      # Only create config file
+        voodocs init                    # Interactive wizard
+        voodocs init --upgrade          # Upgrade existing config
+        voodocs init --non-interactive  # Use all defaults
     """
+    
     cwd = Path.cwd()
     config_path = cwd / '.voodocs.json'
     
-    # Check if config already exists
-    if config_path.exists():
-        click.echo(click.style('⚠ .voodocs.json already exists', fg='yellow'))
-        if not click.confirm('Overwrite existing configuration?'):
+    # Check if this is an upgrade or fresh install
+    existing_config = None
+    is_upgrade = config_path.exists()
+    
+    if is_upgrade:
+        try:
+            with open(config_path) as f:
+                existing_config = json.load(f)
+        except:
+            existing_config = None
+    
+    # Print welcome header
+    click.echo()
+    if is_upgrade:
+        click.echo(click.style('╔══════════════════════════════════════════╗', fg='yellow', bold=True))
+        click.echo(click.style('║   🔄 VooDocs Upgrade Wizard             ║', fg='yellow', bold=True))
+        click.echo(click.style('╚══════════════════════════════════════════╝', fg='yellow', bold=True))
+        click.echo()
+        click.echo(click.style('Existing configuration detected!', fg='yellow'))
+        click.echo('This wizard will help you add any missing features.')
+    else:
+        click.echo(click.style('╔══════════════════════════════════════════╗', fg='cyan', bold=True))
+        click.echo(click.style('║   🎉 Welcome to VooDocs Setup Wizard   ║', fg='cyan', bold=True))
+        click.echo(click.style('╚══════════════════════════════════════════╝', fg='cyan', bold=True))
+    click.echo()
+    
+    # Detect what's already configured
+    has_ai_instructions = _check_ai_instructions(cwd)
+    has_examples = (cwd / 'voodocs-examples').exists()
+    has_gitignore_entry = _check_gitignore(cwd, '.voodocs.json')
+    
+    if is_upgrade and not non_interactive:
+        click.echo(click.style('Current Setup:', fg='cyan', bold=True))
+        click.echo(f'  Configuration:     {_status_icon(True)} .voodocs.json exists')
+        click.echo(f'  AI Instructions:   {_status_icon(has_ai_instructions)} {_get_ai_file_status(cwd)}')
+        click.echo(f'  Example Files:     {_status_icon(has_examples)} voodocs-examples/')
+        click.echo(f'  .gitignore:        {_status_icon(has_gitignore_entry)} .voodocs.json entry')
+        click.echo()
+        
+        if not click.confirm('Continue with upgrade?', default=True):
+            click.echo('Aborted.')
+            return
+        click.echo()
+    
+    # Step 1: Project Information
+    click.echo(click.style('📋 Step 1: Project Information', fg='blue', bold=True))
+    click.echo()
+    
+    # Auto-detect or use existing config
+    project_name = _get_value(existing_config, 'project.name', _detect_project_name(cwd))
+    project_version = _get_value(existing_config, 'project.version', _detect_version(cwd))
+    repository_url = _get_value(existing_config, 'project.repository', _detect_repository(cwd))
+    project_purpose = _get_value(existing_config, 'project.purpose', f'{project_name} project')
+    
+    if non_interactive:
+        name = project_name
+        version = project_version
+        repository = repository_url
+        purpose = project_purpose
+    else:
+        if is_upgrade:
+            click.echo(f'Current values (press Enter to keep):')
+        name = click.prompt('Project name', default=project_name)
+        purpose = click.prompt('Project purpose', default=project_purpose)
+        version = click.prompt('Current version', default=project_version)
+        repository = click.prompt('Repository URL (leave empty to skip)', default=repository_url or '', show_default=False)
+    
+    click.echo()
+    
+    # Step 2: Annotation Format
+    click.echo(click.style('✨ Step 2: Annotation Format', fg='blue', bold=True))
+    click.echo()
+    
+    # DarkArts symbolic format only
+    format_choice = 'darkarts'
+    click.echo('Using DarkArts symbolic format:')
+    click.echo('  ⊢{...} module_purpose    ∂{...} dependencies    ⚠{...} assumptions')
+    click.echo('  ⊳{...} preconditions     ⊲{...} postconditions  ⊨{...} invariants')
+    click.echo('  ⚡{...} complexity        🔒{...} security')
+    click.echo(click.style('  ✓', fg='green') + ' AI-native symbolic annotations')
+    
+    click.echo()
+    
+    # Step 3: AI Assistant Setup
+    click.echo(click.style('🤖 Step 3: AI Assistant Setup', fg='blue', bold=True))
+    click.echo()
+    
+    detected_ai = _detect_ai_environment()
+    
+    if has_ai_instructions and is_upgrade:
+        click.echo(f'{_status_icon(True)} AI instructions already configured')
+        if non_interactive:
+            setup_ai = False
+            ai_choice = None
+        else:
+            setup_ai = click.confirm('Update AI instructions?', default=False)
+            if setup_ai:
+                ai_choice = click.prompt(
+                    'Which AI assistant?',
+                    type=click.Choice(['cursor', 'claude', 'default'], case_sensitive=False),
+                    default=detected_ai or 'cursor'
+                )
+            else:
+                ai_choice = None
+    else:
+        if detected_ai:
+            click.echo(f'Detected AI environment: {click.style(detected_ai, fg="green", bold=True)}')
+        else:
+            click.echo('No AI environment detected')
+        click.echo()
+        
+        if non_interactive:
+            setup_ai = detected_ai is not None
+            ai_choice = detected_ai or 'cursor'
+        else:
+            setup_ai = click.confirm('Generate AI instructions for your coding assistant?', default=True)
+            if setup_ai:
+                ai_choice = click.prompt(
+                    'Which AI assistant?',
+                    type=click.Choice(['cursor', 'claude', 'default'], case_sensitive=False),
+                    default=detected_ai or 'cursor'
+                )
+            else:
+                ai_choice = None
+    
+    click.echo()
+    
+    # Step 4: Privacy Settings
+    click.echo(click.style('🔒 Step 4: Privacy Settings', fg='blue', bold=True))
+    click.echo()
+    
+    if has_gitignore_entry and is_upgrade:
+        click.echo(f'{_status_icon(True)} .gitignore already configured')
+        add_to_gitignore = False
+    else:
+        if non_interactive:
+            is_private = True
+            add_to_gitignore = True
+        else:
+            is_private = click.confirm('Is this a private project?', default=True)
+            add_to_gitignore = False
+            if is_private:
+                add_to_gitignore = click.confirm('Add .voodocs.json to .gitignore?', default=True)
+    
+    click.echo()
+    
+    # Step 5: Example Files
+    click.echo(click.style('📝 Step 5: Example Files', fg='blue', bold=True))
+    click.echo()
+    
+    if has_examples and is_upgrade:
+        click.echo(f'{_status_icon(True)} Example files already exist')
+        create_examples = False
+    else:
+        if non_interactive:
+            create_examples = True
+        else:
+            create_examples = click.confirm('Create example annotated files?', default=not is_upgrade)
+    
+    click.echo()
+    
+    # Show configuration summary
+    click.echo(click.style('📊 Configuration Summary', fg='cyan', bold=True))
+    click.echo(click.style('─' * 50, fg='cyan'))
+    click.echo(f'  Project Name:      {click.style(name, fg="green")}')
+    click.echo(f'  Purpose:           {purpose}')
+    click.echo(f'  Version:           {version}')
+    if repository:
+        click.echo(f'  Repository:        {repository}')
+    click.echo(f'  Format:            {click.style(format_choice, fg="green", bold=True)}')
+    if setup_ai and ai_choice:
+        click.echo(f'  AI Assistant:      {click.style(ai_choice, fg="green")} {_status_icon(True, "new") if not has_ai_instructions else ""}')
+    if add_to_gitignore:
+        click.echo(f'  .gitignore:        {click.style("Yes", fg="green")} {_status_icon(True, "new")}')
+    if create_examples:
+        click.echo(f'  Example Files:     {click.style("Yes", fg="green")} {_status_icon(True, "new")}')
+    click.echo(click.style('─' * 50, fg='cyan'))
+    click.echo()
+    
+    if not non_interactive:
+        action = 'upgrade' if is_upgrade else 'create'
+        if not click.confirm(f'Proceed to {action} configuration?', default=True):
             click.echo('Aborted.')
             return
+        click.echo()
+    
+    # Create/update configuration
+    action_verb = 'Updating' if is_upgrade else 'Creating'
+    click.echo(click.style(f'⚙️  {action_verb} configuration...', fg='blue'))
     
-    # Create default configuration
     config = {
         "version": "1.0",
-        "format": format,
+        "project": {
+            "name": name,
+            "purpose": purpose,
+            "version": version,
+            "repository": repository if repository else None
+        },
+        "format": format_choice,
         "validation": {
             "semantic": True,
             "performance": True,
@@ -76,40 +274,252 @@ def init(format, config_only):
         ]
     }
     
+    # Merge with existing config if upgrading
+    if is_upgrade and existing_config:
+        # Preserve any custom fields
+        for key in existing_config:
+            if key not in config:
+                config[key] = existing_config[key]
+    
     # Write configuration
     with open(config_path, 'w') as f:
         json.dump(config, f, indent=2)
     
-    click.echo(click.style('✓ Created .voodocs.json', fg='green'))
+    verb = 'Updated' if is_upgrade else 'Created'
+    click.echo(click.style(f'  ✓ {verb} .voodocs.json', fg='green'))
     
-    if not config_only:
-        # Create example files
+    # Add to .gitignore if requested
+    if add_to_gitignore:
+        _add_to_gitignore(cwd, '.voodocs.json')
+        click.echo(click.style('  ✓ Added to .gitignore', fg='green'))
+    
+    # Generate AI instructions
+    if setup_ai and ai_choice:
+        click.echo(click.style(f'  ⚙️  Generating {ai_choice} instructions...', fg='blue'))
+        _generate_ai_instructions(cwd, ai_choice, format_choice)
+        click.echo(click.style(f'  ✓ Created AI instructions', fg='green'))
+    
+    # Create example files
+    if create_examples:
+        click.echo(click.style('  ⚙️  Creating example files...', fg='blue'))
         examples_dir = cwd / 'voodocs-examples'
         examples_dir.mkdir(exist_ok=True)
         
-        if format == 'voodocs':
-            create_voodocs_example(examples_dir)
+        if format_choice == 'voodocs':
+            _create_voodocs_examples(examples_dir)
         else:
-            create_darkarts_example(examples_dir)
+            _create_darkarts_examples(examples_dir)
         
-        click.echo(click.style(f'✓ Created example files in {examples_dir}/', fg='green'))
+        click.echo(click.style(f'  ✓ Created examples in {examples_dir}/', fg='green'))
     
+    # Success!
     click.echo()
-    click.echo(click.style('🎉 VooDocs initialized successfully!', fg='green', bold=True))
+    if is_upgrade:
+        click.echo(click.style('╔══════════════════════════════════════════╗', fg='green', bold=True))
+        click.echo(click.style('║   ✅ VooDocs Upgrade Complete!         ║', fg='green', bold=True))
+        click.echo(click.style('╚══════════════════════════════════════════╝', fg='green', bold=True))
+    else:
+        click.echo(click.style('╔══════════════════════════════════════════╗', fg='green', bold=True))
+        click.echo(click.style('║   🎉 VooDocs Setup Complete!           ║', fg='green', bold=True))
+        click.echo(click.style('╚══════════════════════════════════════════╝', fg='green', bold=True))
     click.echo()
-    click.echo('Next steps:')
+    click.echo(click.style('Next steps:', fg='cyan', bold=True))
     click.echo('  1. Review .voodocs.json configuration')
-    click.echo('  2. Add annotations to your code')
-    click.echo('  3. Run: voodocs validate .')
-    click.echo('  4. Run: voodocs generate . ./docs')
+    if setup_ai and ai_choice:
+        ai_file = '.cursorrules' if ai_choice == 'cursor' else f'{ai_choice}-instructions.md'
+        click.echo(f'  2. Your AI assistant will use {ai_file}')
+    click.echo('  3. Add annotations to your code')
+    click.echo('  4. Run: voodocs validate .')
+    click.echo('  5. Run: voodocs generate . ./docs')
+    click.echo()
+    if is_upgrade:
+        click.echo(click.style('💡 Tip:', fg='yellow') + ' Run ' + click.style('voodocs init --upgrade', fg='cyan') + ' again after future updates!')
+    click.echo()
+    click.echo(f'Documentation: {click.style("https://voodocs.com/docs", fg="blue", underline=True)}')
     click.echo()
-    click.echo('Documentation: https://voodocs.com/docs')
 
 
-def create_voodocs_example(examples_dir: Path):
+def _status_icon(exists: bool, label: str = None) -> str:
+    """Return a status icon."""
+    if label == "new":
+        return click.style('🆕', fg='green')
+    return click.style('✓', fg='green') if exists else click.style('✗', fg='red')
+
+
+def _get_value(config: Optional[Dict[str, Any]], path: str, default: Any) -> Any:
+    """Get a value from nested config dict using dot notation."""
+    if not config:
+        return default
+    
+    keys = path.split('.')
+    value = config
+    for key in keys:
+        if isinstance(value, dict) and key in value:
+            value = value[key]
+        else:
+            return default
+    
+    return value if value is not None else default
+
+
+def _check_ai_instructions(cwd: Path) -> bool:
+    """Check if AI instructions exist."""
+    return (
+        (cwd / '.cursorrules').exists() or
+        (cwd / '.claude' / 'instructions.md').exists() or
+        (cwd / 'AI_INSTRUCTIONS.md').exists()
+    )
+
+
+def _get_ai_file_status(cwd: Path) -> str:
+    """Get status of AI instruction files."""
+    files = []
+    if (cwd / '.cursorrules').exists():
+        files.append('.cursorrules')
+    if (cwd / '.claude' / 'instructions.md').exists():
+        files.append('.claude/instructions.md')
+    if (cwd / 'AI_INSTRUCTIONS.md').exists():
+        files.append('AI_INSTRUCTIONS.md')
+    
+    return ', '.join(files) if files else 'none'
+
+
+def _check_gitignore(cwd: Path, entry: str) -> bool:
+    """Check if entry exists in .gitignore."""
+    gitignore = cwd / '.gitignore'
+    if not gitignore.exists():
+        return False
+    
+    content = gitignore.read_text()
+    return entry in content
+
+
+def _detect_project_name(cwd: Path) -> str:
+    """Detect project name from directory or package.json."""
+    package_json = cwd / 'package.json'
+    if package_json.exists():
+        try:
+            with open(package_json) as f:
+                data = json.load(f)
+                if 'name' in data:
+                    return data['name']
+        except:
+            pass
+    
+    return cwd.name
+
+
+def _detect_version(cwd: Path) -> str:
+    """Detect project version."""
+    package_json = cwd / 'package.json'
+    if package_json.exists():
+        try:
+            with open(package_json) as f:
+                data = json.load(f)
+                if 'version' in data:
+                    return data['version']
+        except:
+            pass
+    
+    pyproject = cwd / 'pyproject.toml'
+    if pyproject.exists():
+        try:
+            with open(pyproject) as f:
+                for line in f:
+                    if line.startswith('version'):
+                        return line.split('=')[1].strip().strip('"\'')
+        except:
+            pass
+    
+    version_file = cwd / 'VERSION'
+    if version_file.exists():
+        try:
+            return version_file.read_text().strip()
+        except:
+            pass
+    
+    return '1.0.0'
+
+
+def _detect_repository(cwd: Path) -> Optional[str]:
+    """Detect repository URL from git config."""
+    try:
+        result = subprocess.run(
+            ['git', 'config', '--get', 'remote.origin.url'],
+            capture_output=True,
+            text=True,
+            cwd=cwd
+        )
+        if result.returncode == 0:
+            url = result.stdout.strip()
+            if url.startswith('git@github.com:'):
+                url = url.replace('git@github.com:', 'https://github.com/')
+            if url.endswith('.git'):
+                url = url[:-4]
+            return url
+    except:
+        pass
+    
+    return None
+
+
+def _detect_ai_environment() -> Optional[str]:
+    """Detect which AI environment is being used."""
+    if os.environ.get('CURSOR_USER') or Path('.cursorrules').exists():
+        return 'cursor'
+    
+    if os.environ.get('CLAUDE_API_KEY') or Path('.claude').exists():
+        return 'claude'
+    
+    return None
+
+
+def _add_to_gitignore(cwd: Path, entry: str):
+    """Add an entry to .gitignore."""
+    gitignore = cwd / '.gitignore'
+    
+    if gitignore.exists():
+        content = gitignore.read_text()
+        if entry in content:
+            return
+    else:
+        content = ''
+    
+    if content and not content.endswith('\n'):
+        content += '\n'
+    content += f'\n# VooDocs\n{entry}\n'
+    
+    gitignore.write_text(content)
+
+
+def _generate_ai_instructions(cwd: Path, ai_type: str, format_type: str):
+    """Generate AI instructions file."""
+    cli_dir = Path(__file__).parent
+    template_path = cli_dir.parent / 'darkarts' / 'instructions' / f'{ai_type}.md'
+    
+    if not template_path.exists():
+        template_path = cli_dir.parent / 'darkarts' / 'instructions' / 'default.md'
+    
+    if not template_path.exists():
+        return
+    
+    instructions = template_path.read_text()
+    
+    if ai_type == 'cursor':
+        output_file = cwd / '.cursorrules'
+    elif ai_type == 'claude':
+        output_dir = cwd / '.claude'
+        output_dir.mkdir(exist_ok=True)
+        output_file = output_dir / 'instructions.md'
+    else:
+        output_file = cwd / 'AI_INSTRUCTIONS.md'
+    
+    output_file.write_text(instructions)
+
+
+def _create_voodocs_examples(examples_dir: Path):
     """Create example files with @voodocs annotations."""
     
-    # TypeScript example
     ts_example = '''/**@voodocs
 module_purpose: "Example TypeScript module demonstrating @voodocs annotations"
 dependencies: []
@@ -137,41 +547,11 @@ export function greet(name: string, age: number): string {
 '''
     
     (examples_dir / 'example.ts').write_text(ts_example)
-    
-    # Python example
-    py_example = '''"""@voodocs
-module_purpose: "Example Python module demonstrating @voodocs annotations"
-dependencies: []
-assumptions: ["Python 3.7+"]
-"""
-
-def calculate_total(prices: list[float], tax_rate: float) -> float:
-    """@voodocs
-    preconditions: [
-      "prices is a non-empty list of positive numbers",
-      "tax_rate is between 0 and 1"
-    ]
-    postconditions: [
-      "Returns the total with tax applied",
-      "Result is greater than or equal to sum of prices"
-    ]
-    invariants: [
-      "Does not modify the prices list"
-    ]
-    side_effects: []
-    complexity: "O(n) where n is the length of prices"
-    """
-    subtotal = sum(prices)
-    return subtotal * (1 + tax_rate)
-'''
-    
-    (examples_dir / 'example.py').write_text(py_example)
 
 
-def create_darkarts_example(examples_dir: Path):
+def _create_darkarts_examples(examples_dir: Path):
     """Create example files with symbolic @darkarts annotations."""
     
-    # TypeScript example
     ts_example = '''/**@darkarts
 ⊢{Example TypeScript module demonstrating symbolic @darkarts annotations}
 ∂{}
@@ -190,7 +570,7 @@ def create_darkarts_example(examples_dir: Path):
 ⊨{
   Does ¬ modify input parameters
 }
-⚡{}
+⚡{O(1)}
 */
 export function greet(name: string, age: number): string {
   return `Hello, ${name}! You are ${age} years old.`;
@@ -198,31 +578,3 @@ export function greet(name: string, age: number): string {
 '''
     
     (examples_dir / 'example.ts').write_text(ts_example)
-    
-    # Python example
-    py_example = '''"""@darkarts
-⊢{Example Python module demonstrating symbolic @darkarts annotations}
-∂{}
-⚠{Python 3.7+}
-"""
-
-def calculate_total(prices: list[float], tax_rate: float) -> float:
-    """@darkarts
-    ⊳{
-      prices is a non-empty list ∧ ∀ p ∈ prices: p > 0
-      tax_rate ∈ [0, 1]
-    }
-    ⊲{
-      Returns the total with tax applied
-      result ≥ sum(prices)
-    }
-    ⊨{
-      Does ¬ modify the prices list
-    }
-    ⚡{O(n) where n = len(prices)}
-    """
-    subtotal = sum(prices)
-    return subtotal * (1 + tax_rate)
-'''
-    
-    (examples_dir / 'example.py').write_text(py_example)

package/lib/darkarts/annotations/parser.py

@@ -43,23 +43,18 @@ except ImportError:
 
 
 class AnnotationParser:
-    """Parser for DarkArts annotations."""
+    """Parser for DarkArts symbolic annotations (@darkarts only)."""
     
-    # Regex patterns for different languages
-    PATTERNS = {
-        Language.PYTHON: r'"""@voodocs\s*(.*?)\s*"""',
-    }
-    
-    # DarkArts patterns (symbolic annotations) - support both @voodocs and @darkarts
+    # DarkArts patterns (symbolic annotations)
     DARKARTS_PATTERNS = {
-        Language.PYTHON: r'"""@(?:darkarts|voodocs)\s*(.*?)\s*"""',
-        Language.TYPESCRIPT: r'/\*\*@(?:darkarts|voodocs)\s*(.*?)\s*\*/',
-        Language.JAVASCRIPT: r'/\*\*@(?:darkarts|voodocs)\s*(.*?)\s*\*/',
-        Language.JAVA: r'/\*\*@(?:darkarts|voodocs)\s*(.*?)\s*\*/',
-        Language.CPP: r'/\*\*@(?:darkarts|voodocs)\s*(.*?)\s*\*/',
-        Language.CSHARP: r'/\*\*@(?:darkarts|voodocs)\s*(.*?)\s*\*/',
-        Language.GO: r'/\*\*@(?:darkarts|voodocs)\s*(.*?)\s*\*/',
-        Language.RUST: r'/\*\*@(?:darkarts|voodocs)\s*(.*?)\s*\*/',
+        Language.PYTHON: r'"""@darkarts\s*(.*?)\s*"""',
+        Language.TYPESCRIPT: r'/\*\*@darkarts\s*(.*?)\s*\*/',
+        Language.JAVASCRIPT: r'/\*\*@darkarts\s*(.*?)\s*\*/',
+        Language.JAVA: r'/\*\*@darkarts\s*(.*?)\s*\*/',
+        Language.CPP: r'/\*\*@darkarts\s*(.*?)\s*\*/',
+        Language.CSHARP: r'/\*\*@darkarts\s*(.*?)\s*\*/',
+        Language.GO: r'/\*\*@darkarts\s*(.*?)\s*\*/',
+        Language.RUST: r'/\*\*@darkarts\s*(.*?)\s*\*/',
     }
     
     def __init__(self):