claude-dev-cli 0.8.1__tar.gz → 0.8.2__tar.gz

{claude_dev_cli-0.8.1/src/claude_dev_cli.egg-info → claude_dev_cli-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.8.1
+Version: 0.8.2
 Summary: A powerful CLI tool for developers using Claude AI with multi-API routing, test generation, code review, and usage tracking
 Author-email: Julio <thinmanj@users.noreply.github.com>
 License: MIT
@@ -85,7 +85,8 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
   - `git commit`, `generate tests`, `generate docs` (v0.8.1)
 - **Git Integration**: Automatically include branch, commits, modified files
 - **Dependency Analysis**: Parse imports and include related files
-- **Error Parsing**: Structured Python traceback parsing
+- **Multi-Language Error Parsing** (v0.8.2): Python, JavaScript/TypeScript, Go, Rust, Java
+- **Context Summary** (v0.8.2): Preview context before API calls with `cdc context summary`
 - **Smart Truncation**: Prevent token limits with configurable file size limits
 - **Project Memory**: Remember preferences per project
 - **Global Config**: Set context defaults in `~/.claude-dev-cli/config.json`
@@ -199,7 +200,7 @@ git add .
 cdc git commit --auto-context
 ```
 
-### 4. Context-Aware Operations (NEW in v0.8.0)
+### 4. Context-Aware Operations (v0.8.0+)
 
 ```bash
 # Auto-context includes: git info, dependencies, related files
@@ -208,9 +209,16 @@ cdc git commit --auto-context
 cdc review mymodule.py --auto-context
 # ✓ Context gathered (git, dependencies, tests)
 
-# Debug with parsed error details
+# Debug with parsed error details (multi-language support)
 python broken.py 2>&1 | cdc debug -f broken.py --auto-context
+node app.js 2>&1 | cdc debug --auto-context  # JavaScript/TypeScript
+go run main.go 2>&1 | cdc debug --auto-context  # Go
 # ✓ Context gathered (error details, git context)
+# Supports: Python, JavaScript, TypeScript, Go, Rust, Java
+
+# Preview context before making API calls - NEW in v0.8.2
+cdc context summary mymodule.py
+# Shows: files, sizes, lines, estimated tokens, truncation warnings
 
 # Ask questions with file context
 cdc ask -f mycode.py --auto-context "how can I improve this?"

{claude_dev_cli-0.8.1 → claude_dev_cli-0.8.2}/README.md

@@ -41,7 +41,8 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
   - `git commit`, `generate tests`, `generate docs` (v0.8.1)
 - **Git Integration**: Automatically include branch, commits, modified files
 - **Dependency Analysis**: Parse imports and include related files
-- **Error Parsing**: Structured Python traceback parsing
+- **Multi-Language Error Parsing** (v0.8.2): Python, JavaScript/TypeScript, Go, Rust, Java
+- **Context Summary** (v0.8.2): Preview context before API calls with `cdc context summary`
 - **Smart Truncation**: Prevent token limits with configurable file size limits
 - **Project Memory**: Remember preferences per project
 - **Global Config**: Set context defaults in `~/.claude-dev-cli/config.json`
@@ -155,7 +156,7 @@ git add .
 cdc git commit --auto-context
 ```
 
-### 4. Context-Aware Operations (NEW in v0.8.0)
+### 4. Context-Aware Operations (v0.8.0+)
 
 ```bash
 # Auto-context includes: git info, dependencies, related files
@@ -164,9 +165,16 @@ cdc git commit --auto-context
 cdc review mymodule.py --auto-context
 # ✓ Context gathered (git, dependencies, tests)
 
-# Debug with parsed error details
+# Debug with parsed error details (multi-language support)
 python broken.py 2>&1 | cdc debug -f broken.py --auto-context
+node app.js 2>&1 | cdc debug --auto-context  # JavaScript/TypeScript
+go run main.go 2>&1 | cdc debug --auto-context  # Go
 # ✓ Context gathered (error details, git context)
+# Supports: Python, JavaScript, TypeScript, Go, Rust, Java
+
+# Preview context before making API calls - NEW in v0.8.2
+cdc context summary mymodule.py
+# Shows: files, sizes, lines, estimated tokens, truncation warnings
 
 # Ask questions with file context
 cdc ask -f mycode.py --auto-context "how can I improve this?"

{claude_dev_cli-0.8.1 → claude_dev_cli-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-dev-cli"
-version = "0.8.1"
+version = "0.8.2"
 description = "A powerful CLI tool for developers using Claude AI with multi-API routing, test generation, code review, and usage tracking"
 readme = "README.md"
 requires-python = ">=3.9"

{claude_dev_cli-0.8.1 → claude_dev_cli-0.8.2}/src/claude_dev_cli/__init__.py

@@ -9,7 +9,7 @@ Features:
 - Interactive and single-shot modes
 """
 
-__version__ = "0.8.1"
+__version__ = "0.8.2"
 __author__ = "Julio"
 __license__ = "MIT"
 

{claude_dev_cli-0.8.1 → claude_dev_cli-0.8.2}/src/claude_dev_cli/cli.py

@@ -884,6 +884,107 @@ def git_commit(ctx: click.Context, api: Optional[str], auto_context: bool) -> No
         sys.exit(1)
 
 
+@main.group()
+def context() -> None:
+    """Context gathering tools and information."""
+    pass
+
+
+@context.command('summary')
+@click.argument('file_path', type=click.Path(exists=True))
+@click.option('--include-git/--no-git', default=True, help='Include git context')
+@click.option('--include-deps/--no-deps', default=True, help='Include dependencies')
+@click.option('--include-tests/--no-tests', default=True, help='Include test files')
+@click.pass_context
+def context_summary(
+    ctx: click.Context,
+    file_path: str,
+    include_git: bool,
+    include_deps: bool,
+    include_tests: bool
+) -> None:
+    """Show what context would be gathered for a file."""
+    from claude_dev_cli.context import ContextGatherer
+    from rich.table import Table
+    
+    console = ctx.obj['console']
+    
+    try:
+        file_path_obj = Path(file_path)
+        gatherer = ContextGatherer()
+        
+        # Gather context
+        with console.status("[bold blue]Analyzing context..."):
+            context = gatherer.gather_for_review(
+                file_path_obj,
+                include_git=include_git,
+                include_tests=include_tests
+            )
+        
+        # Display summary
+        console.print(f"\n[bold cyan]Context Summary for:[/bold cyan] {file_path}\n")
+        
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Type", style="cyan")
+        table.add_column("Content", style="white")
+        table.add_column("Size", justify="right", style="yellow")
+        table.add_column("Lines", justify="right", style="green")
+        table.add_column("Truncated", justify="center", style="red")
+        
+        total_chars = 0
+        total_lines = 0
+        
+        for item in context.items:
+            lines = len(item.content.split('\n'))
+            chars = len(item.content)
+            truncated = "✓" if item.metadata.get('truncated') else ""
+            
+            # Format content preview
+            if item.type == 'file':
+                content = item.metadata.get('path', 'unknown')
+                if item.metadata.get('is_test'):
+                    content += " [TEST]"
+            elif item.type == 'git':
+                branch = item.metadata.get('branch', 'unknown')
+                modified = item.metadata.get('modified_count', 0)
+                content = f"Branch: {branch}, {modified} modified files"
+            elif item.type == 'dependency':
+                dep_files = item.metadata.get('dependency_files', [])
+                content = f"{len(dep_files)} dependency files"
+            else:
+                content = item.type
+            
+            table.add_row(
+                item.type.title(),
+                content[:60] + "..." if len(content) > 60 else content,
+                f"{chars:,}",
+                f"{lines:,}",
+                truncated
+            )
+            
+            total_chars += chars
+            total_lines += lines
+        
+        console.print(table)
+        
+        # Show totals
+        console.print(f"\n[bold]Total:[/bold]")
+        console.print(f"  Characters: [yellow]{total_chars:,}[/yellow]")
+        console.print(f"  Lines: [green]{total_lines:,}[/green]")
+        console.print(f"  Estimated tokens: [cyan]~{total_chars // 4:,}[/cyan] (rough estimate)")
+        
+        # Show any truncation warnings
+        truncated_items = [item for item in context.items if item.metadata.get('truncated')]
+        if truncated_items:
+            console.print(f"\n[yellow]⚠ {len(truncated_items)} item(s) truncated to fit size limits[/yellow]")
+        
+        console.print(f"\n[dim]Use --auto-context with commands to include this context[/dim]")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
 @main.command('usage')
 @click.option('--days', type=int, help='Filter by days')
 @click.option('--api', help='Filter by API config')

{claude_dev_cli-0.8.1 → claude_dev_cli-0.8.2}/src/claude_dev_cli/context.py

@@ -339,10 +339,25 @@ class DependencyAnalyzer:
 
 
 class ErrorContext:
-    """Parse and format error context."""
+    """Parse and format error context for multiple languages."""
     
     @staticmethod
-    def parse_traceback(error_text: str) -> Dict[str, Any]:
+    def detect_language(error_text: str) -> str:
+        """Detect programming language from error format."""
+        if 'Traceback (most recent call last):' in error_text or 'File "' in error_text:
+            return 'python'
+        elif 'at ' in error_text and ('.js:' in error_text or '.ts:' in error_text):
+            return 'javascript'
+        elif 'panic:' in error_text and '.go:' in error_text:
+            return 'go'
+        elif 'thread' in error_text and 'panicked at' in error_text and '.rs:' in error_text:
+            return 'rust'
+        elif 'at ' in error_text and '.java:' in error_text:
+            return 'java'
+        return 'unknown'
+    
+    @staticmethod
+    def parse_python_traceback(error_text: str) -> Dict[str, Any]:
         """Parse Python traceback into structured data."""
         lines = error_text.split('\n')
         
@@ -391,24 +406,183 @@ class ErrorContext:
                     'raw': error_text
                 }
         
-        return {'frames': frames, 'raw': error_text}
+        return {'frames': frames, 'raw': error_text, 'language': 'python'}
+    
+    @staticmethod
+    def parse_javascript_stack(error_text: str) -> Dict[str, Any]:
+        """Parse JavaScript/TypeScript stack trace."""
+        lines = error_text.split('\n')
+        frames = []
+        error_type = None
+        error_message = None
+        
+        for line in lines:
+            # Error message usually first: "Error: message" or "TypeError: message"
+            if not error_type and (':' in line and not line.strip().startswith('at')):
+                parts = line.split(':', 1)
+                error_type = parts[0].strip()
+                error_message = parts[1].strip() if len(parts) > 1 else ''
+            # Stack frame: "at functionName (file.js:line:col)" or "at file.js:line:col"
+            elif line.strip().startswith('at '):
+                match = re.search(r'at\s+(?:(.+?)\s+)?\(([^)]+)\)|(\S+)$', line)
+                if match:
+                    function = match.group(1) or 'anonymous'
+                    location = match.group(2) or match.group(3)
+                    if location and ':' in location:
+                        parts = location.rsplit(':', 2)
+                        frames.append({
+                            'file': parts[0],
+                            'line': int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else None,
+                            'column': int(parts[2]) if len(parts) > 2 and parts[2].isdigit() else None,
+                            'function': function
+                        })
+        
+        return {
+            'frames': frames,
+            'error_type': error_type,
+            'error_message': error_message,
+            'raw': error_text,
+            'language': 'javascript'
+        }
+    
+    @staticmethod
+    def parse_go_panic(error_text: str) -> Dict[str, Any]:
+        """Parse Go panic trace."""
+        lines = error_text.split('\n')
+        frames = []
+        error_message = None
+        
+        for line in lines:
+            # Panic message: "panic: message"
+            if line.startswith('panic:'):
+                error_message = line.replace('panic:', '').strip()
+            # Stack frame: "function(args)" followed by "\tfile.go:line +0xhex"
+            elif '\t' in line and '.go:' in line:
+                match = re.search(r'([^/\s]+\.go):(\d+)', line)
+                if match:
+                    frames.append({
+                        'file': match.group(1),
+                        'line': int(match.group(2)),
+                        'function': 'goroutine'
+                    })
+        
+        return {
+            'frames': frames,
+            'error_type': 'panic',
+            'error_message': error_message,
+            'raw': error_text,
+            'language': 'go'
+        }
+    
+    @staticmethod
+    def parse_rust_panic(error_text: str) -> Dict[str, Any]:
+        """Parse Rust panic message."""
+        lines = error_text.split('\n')
+        frames = []
+        error_message = None
+        
+        for line in lines:
+            # Panic message: "thread 'main' panicked at 'message', file.rs:line:col"
+            if 'panicked at' in line:
+                match = re.search(r"panicked at '([^']+)', ([^:]+):(\d+):(\d+)", line)
+                if match:
+                    error_message = match.group(1)
+                    frames.append({
+                        'file': match.group(2),
+                        'line': int(match.group(3)),
+                        'column': int(match.group(4)),
+                        'function': 'panic'
+                    })
+            # Stack backtrace frames
+            elif '.rs:' in line:
+                match = re.search(r'([^/\s]+\.rs):(\d+):(\d+)', line)
+                if match:
+                    frames.append({
+                        'file': match.group(1),
+                        'line': int(match.group(2)),
+                        'column': int(match.group(3)),
+                        'function': 'unknown'
+                    })
+        
+        return {
+            'frames': frames,
+            'error_type': 'panic',
+            'error_message': error_message,
+            'raw': error_text,
+            'language': 'rust'
+        }
+    
+    @staticmethod
+    def parse_java_stack(error_text: str) -> Dict[str, Any]:
+        """Parse Java stack trace."""
+        lines = error_text.split('\n')
+        frames = []
+        error_type = None
+        error_message = None
+        
+        for line in lines:
+            # Exception message: "java.lang.NullPointerException: message"
+            if not error_type and 'Exception' in line or 'Error' in line:
+                parts = line.split(':', 1)
+                error_type = parts[0].strip().split('.')[-1]  # Get last part of package
+                error_message = parts[1].strip() if len(parts) > 1 else ''
+            # Stack frame: "at package.Class.method(File.java:line)"
+            elif line.strip().startswith('at '):
+                match = re.search(r'at\s+([^(]+)\(([^:]+\.java):(\d+)\)', line)
+                if match:
+                    frames.append({
+                        'function': match.group(1),
+                        'file': match.group(2),
+                        'line': int(match.group(3))
+                    })
+        
+        return {
+            'frames': frames,
+            'error_type': error_type,
+            'error_message': error_message,
+            'raw': error_text,
+            'language': 'java'
+        }
+    
+    @staticmethod
+    def parse_traceback(error_text: str) -> Dict[str, Any]:
+        """Parse error/traceback with language auto-detection."""
+        language = ErrorContext.detect_language(error_text)
+        
+        if language == 'python':
+            return ErrorContext.parse_python_traceback(error_text)
+        elif language == 'javascript':
+            return ErrorContext.parse_javascript_stack(error_text)
+        elif language == 'go':
+            return ErrorContext.parse_go_panic(error_text)
+        elif language == 'rust':
+            return ErrorContext.parse_rust_panic(error_text)
+        elif language == 'java':
+            return ErrorContext.parse_java_stack(error_text)
+        else:
+            return {'raw': error_text, 'language': 'unknown'}
     
     @staticmethod
     def format_for_ai(error_text: str) -> str:
-        """Format error for AI consumption."""
+        """Format error for AI consumption with language detection."""
         parsed = ErrorContext.parse_traceback(error_text)
         
         if 'error_type' not in parsed:
             return error_text
         
+        language = parsed.get('language', 'unknown')
         parts = [
+            f"Language: {language.title()}",
             f"Error Type: {parsed['error_type']}",
             f"Error Message: {parsed.get('error_message', 'N/A')}",
             "\nStack Trace:"
         ]
         
         for i, frame in enumerate(parsed.get('frames', []), 1):
-            parts.append(f"  {i}. {frame.get('file', 'unknown')}:{frame.get('line', '?')} in {frame.get('function', 'unknown')}")
+            file_loc = f"{frame.get('file', 'unknown')}:{frame.get('line', '?')}"
+            if 'column' in frame:
+                file_loc += f":{frame.get('column', '?')}"
+            parts.append(f"  {i}. {file_loc} in {frame.get('function', 'unknown')}")
             if 'code' in frame:
                 parts.append(f"     > {frame['code']}")
         

{claude_dev_cli-0.8.1 → claude_dev_cli-0.8.2/src/claude_dev_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.8.1
+Version: 0.8.2
 Summary: A powerful CLI tool for developers using Claude AI with multi-API routing, test generation, code review, and usage tracking
 Author-email: Julio <thinmanj@users.noreply.github.com>
 License: MIT
@@ -85,7 +85,8 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
   - `git commit`, `generate tests`, `generate docs` (v0.8.1)
 - **Git Integration**: Automatically include branch, commits, modified files
 - **Dependency Analysis**: Parse imports and include related files
-- **Error Parsing**: Structured Python traceback parsing
+- **Multi-Language Error Parsing** (v0.8.2): Python, JavaScript/TypeScript, Go, Rust, Java
+- **Context Summary** (v0.8.2): Preview context before API calls with `cdc context summary`
 - **Smart Truncation**: Prevent token limits with configurable file size limits
 - **Project Memory**: Remember preferences per project
 - **Global Config**: Set context defaults in `~/.claude-dev-cli/config.json`
@@ -199,7 +200,7 @@ git add .
 cdc git commit --auto-context
 ```
 
-### 4. Context-Aware Operations (NEW in v0.8.0)
+### 4. Context-Aware Operations (v0.8.0+)
 
 ```bash
 # Auto-context includes: git info, dependencies, related files
@@ -208,9 +209,16 @@ cdc git commit --auto-context
 cdc review mymodule.py --auto-context
 # ✓ Context gathered (git, dependencies, tests)
 
-# Debug with parsed error details
+# Debug with parsed error details (multi-language support)
 python broken.py 2>&1 | cdc debug -f broken.py --auto-context
+node app.js 2>&1 | cdc debug --auto-context  # JavaScript/TypeScript
+go run main.go 2>&1 | cdc debug --auto-context  # Go
 # ✓ Context gathered (error details, git context)
+# Supports: Python, JavaScript, TypeScript, Go, Rust, Java
+
+# Preview context before making API calls - NEW in v0.8.2
+cdc context summary mymodule.py
+# Shows: files, sizes, lines, estimated tokens, truncation warnings
 
 # Ask questions with file context
 cdc ask -f mycode.py --auto-context "how can I improve this?"

{claude_dev_cli-0.8.1 → claude_dev_cli-0.8.2}/tests/test_context.py

@@ -410,6 +410,31 @@ import json.decoder
 class TestErrorContext:
     """Tests for ErrorContext class."""
     
+    def test_detect_language_python(self) -> None:
+        """Test Python language detection."""
+        error_text = "Traceback (most recent call last):\n  File \"test.py\", line 10"
+        assert ErrorContext.detect_language(error_text) == 'python'
+    
+    def test_detect_language_javascript(self) -> None:
+        """Test JavaScript language detection."""
+        error_text = "Error: test\n    at func (app.js:10:5)"
+        assert ErrorContext.detect_language(error_text) == 'javascript'
+    
+    def test_detect_language_go(self) -> None:
+        """Test Go language detection."""
+        error_text = "panic: test\n\tmain.go:15"
+        assert ErrorContext.detect_language(error_text) == 'go'
+    
+    def test_detect_language_rust(self) -> None:
+        """Test Rust language detection."""
+        error_text = "thread 'main' panicked at 'test', main.rs:10:5"
+        assert ErrorContext.detect_language(error_text) == 'rust'
+    
+    def test_detect_language_java(self) -> None:
+        """Test Java language detection."""
+        error_text = "Exception in thread\nat Test.java:10"
+        assert ErrorContext.detect_language(error_text) == 'java'
+    
     def test_parse_simple_traceback(self) -> None:
         """Test parsing a simple Python traceback."""
         error_text = """
@@ -505,6 +530,117 @@ TypeError: execute() missing 1 required positional argument
         assert "TypeError" in context_item.content
         assert "main.py" in context_item.content
         assert "error_type" in context_item.metadata
+    
+    def test_parse_javascript_stack(self) -> None:
+        """Test JavaScript stack trace parsing."""
+        error_text = """
+TypeError: Cannot read property 'foo' of undefined
+    at myFunction (app.js:42:15)
+    at main (index.js:10:5)
+    at startup.js:100:1
+"""
+        
+        parsed = ErrorContext.parse_javascript_stack(error_text)
+        
+        assert parsed['language'] == 'javascript'
+        assert parsed['error_type'] == 'TypeError'
+        assert "Cannot read property" in parsed['error_message']
+        assert len(parsed['frames']) == 3
+        
+        frame1 = parsed['frames'][0]
+        assert frame1['file'] == 'app.js'
+        assert frame1['line'] == 42
+        assert frame1['column'] == 15
+        assert frame1['function'] == 'myFunction'
+    
+    def test_parse_go_panic(self) -> None:
+        """Test Go panic trace parsing."""
+        error_text = """
+panic: runtime error: index out of range
+
+goroutine 1 [running]:
+main.process()
+	/path/to/main.go:45 +0x1a3
+main.main()
+	/path/to/main.go:20 +0x2e
+"""
+        
+        parsed = ErrorContext.parse_go_panic(error_text)
+        
+        assert parsed['language'] == 'go'
+        assert parsed['error_type'] == 'panic'
+        assert 'index out of range' in parsed['error_message']
+        assert len(parsed['frames']) >= 2
+        
+        # Check that we found the files
+        files = [f['file'] for f in parsed['frames']]
+        assert any('main.go' in f for f in files)
+    
+    def test_parse_rust_panic(self) -> None:
+        """Test Rust panic message parsing."""
+        error_text = """
+thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value', src/main.rs:42:9
+stack backtrace:
+   0: rust_begin_unwind
+             at /rustc/lib.rs:1:1
+   1: core::panicking::panic_fmt
+             at src/panicking.rs:50:5
+   2: myapp::process
+             at ./src/lib.rs:100:13
+"""
+        
+        parsed = ErrorContext.parse_rust_panic(error_text)
+        
+        assert parsed['language'] == 'rust'
+        assert parsed['error_type'] == 'panic'
+        assert 'Result::unwrap()' in parsed['error_message']
+        assert len(parsed['frames']) >= 1
+        
+        # First frame should be from the panic location
+        frame1 = parsed['frames'][0]
+        assert 'main.rs' in frame1['file']
+        assert frame1['line'] == 42
+        assert frame1['column'] == 9
+    
+    def test_parse_java_stack(self) -> None:
+        """Test Java stack trace parsing."""
+        error_text = """
+java.lang.NullPointerException: Cannot invoke method on null object
+	at com.example.MyClass.doSomething(MyClass.java:45)
+	at com.example.Main.run(Main.java:20)
+	at com.example.Main.main(Main.java:10)
+"""
+        
+        parsed = ErrorContext.parse_java_stack(error_text)
+        
+        assert parsed['language'] == 'java'
+        assert parsed['error_type'] == 'NullPointerException'
+        assert 'Cannot invoke' in parsed['error_message']
+        assert len(parsed['frames']) == 3
+        
+        frame1 = parsed['frames'][0]
+        assert 'MyClass.java' in frame1['file']
+        assert frame1['line'] == 45
+        assert 'doSomething' in frame1['function']
+    
+    def test_parse_traceback_auto_detects_language(self) -> None:
+        """Test that parse_traceback auto-detects language."""
+        js_error = "Error: test\n    at func (app.js:10:5)"
+        parsed = ErrorContext.parse_traceback(js_error)
+        assert parsed['language'] == 'javascript'
+        
+        go_error = "panic: test\n\tmain.go:15"
+        parsed = ErrorContext.parse_traceback(go_error)
+        assert parsed['language'] == 'go'
+    
+    def test_format_for_ai_includes_language(self) -> None:
+        """Test that formatted output includes language."""
+        error_text = "TypeError: test\n    at func (app.js:10:5)"
+        formatted = ErrorContext.format_for_ai(error_text)
+        
+        assert 'Language: Javascript' in formatted
+        assert 'Error Type: TypeError' in formatted
+        assert 'app.js:10:5' in formatted
 
 
 class TestContextGatherer: