Initial commit
This commit is contained in:
Zhongwei Li
875
scripts/cargo_log_parser.py
Normal file
875
scripts/cargo_log_parser.py
Normal file
@@ -0,0 +1,875 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Cargo Build Log Parser
|
||||
|
||||
A comprehensive parser for cargo build logs that extracts errors, warnings,
|
||||
and notes with full context. Provides regex-based filtering by file path,
|
||||
error message, error code, and more.
|
||||
|
||||
Supports stdin for piping directly from cargo build:
|
||||
cargo build 2>&1 | cargo_log_parser.py --errors --file "tests/.*"
|
||||
|
||||
Designed for LLM consumption with structured output options.
|
||||
"""
|
||||
|
||||
import re
|
||||
import sys
|
||||
import json
|
||||
import argparse
|
||||
from dataclasses import dataclass, field, asdict
|
||||
from pathlib import Path
|
||||
from typing import Optional, TextIO, Callable
|
||||
from enum import Enum
|
||||
|
||||
|
||||
class DiagnosticLevel(Enum):
|
||||
ERROR = "error"
|
||||
WARNING = "warning"
|
||||
NOTE = "note"
|
||||
HELP = "help"
|
||||
INFO = "info"
|
||||
|
||||
|
||||
@dataclass
|
||||
class SourceLocation:
|
||||
"""Represents a location in source code."""
|
||||
file_path: str
|
||||
line: Optional[int] = None
|
||||
column: Optional[int] = None
|
||||
end_line: Optional[int] = None
|
||||
end_column: Optional[int] = None
|
||||
|
||||
def matches_file_regex(self, pattern: str) -> bool:
|
||||
"""Check if file path matches regex pattern."""
|
||||
return bool(re.search(pattern, self.file_path))
|
||||
|
||||
def __str__(self) -> str:
|
||||
if self.line is not None:
|
||||
if self.column is not None:
|
||||
return f"{self.file_path}:{self.line}:{self.column}"
|
||||
return f"{self.file_path}:{self.line}"
|
||||
return self.file_path
|
||||
|
||||
|
||||
@dataclass
|
||||
class Diagnostic:
|
||||
"""Represents a single diagnostic (error/warning/note) from cargo."""
|
||||
level: DiagnosticLevel
|
||||
message: str
|
||||
code: Optional[str] = None # e.g., E0425, E0308
|
||||
location: Optional[SourceLocation] = None
|
||||
raw_text: str = "" # The complete raw text block
|
||||
line_start: int = 0 # Line number in log file where this starts
|
||||
line_end: int = 0 # Line number in log file where this ends
|
||||
children: list = field(default_factory=list) # Sub-diagnostics (notes, help)
|
||||
context_lines: list = field(default_factory=list) # Source code context
|
||||
|
||||
def matches_message_regex(self, pattern: str) -> bool:
|
||||
"""Check if message matches regex pattern."""
|
||||
return bool(re.search(pattern, self.message))
|
||||
|
||||
def matches_code(self, code: str) -> bool:
|
||||
"""Check if error code matches (exact or pattern)."""
|
||||
if self.code is None:
|
||||
return False
|
||||
return bool(re.search(code, self.code))
|
||||
|
||||
def matches_file_regex(self, pattern: str) -> bool:
|
||||
"""Check if any location matches the file pattern."""
|
||||
if self.location and self.location.matches_file_regex(pattern):
|
||||
return True
|
||||
for child in self.children:
|
||||
if child.location and child.location.matches_file_regex(pattern):
|
||||
return True
|
||||
return False
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
"""Convert to dictionary for JSON serialization."""
|
||||
result = {
|
||||
"level": self.level.value,
|
||||
"message": self.message,
|
||||
"code": self.code,
|
||||
"location": str(self.location) if self.location else None,
|
||||
"log_lines": f"{self.line_start}-{self.line_end}",
|
||||
"raw_text": self.raw_text,
|
||||
}
|
||||
if self.children:
|
||||
result["children"] = [c.to_dict() for c in self.children]
|
||||
if self.context_lines:
|
||||
result["context"] = self.context_lines
|
||||
return result
|
||||
|
||||
def summary(self) -> str:
|
||||
"""Return a brief summary for listing."""
|
||||
loc = f" at {self.location}" if self.location else ""
|
||||
code = f"[{self.code}]" if self.code else ""
|
||||
return f"{self.level.value}{code}: {self.message}{loc}"
|
||||
|
||||
|
||||
@dataclass
|
||||
class ParsedLog:
|
||||
"""Container for all parsed diagnostics from a cargo log."""
|
||||
file_path: str
|
||||
diagnostics: list = field(default_factory=list)
|
||||
raw_lines: list = field(default_factory=list)
|
||||
|
||||
@property
|
||||
def errors(self) -> list:
|
||||
return [d for d in self.diagnostics if d.level == DiagnosticLevel.ERROR]
|
||||
|
||||
@property
|
||||
def warnings(self) -> list:
|
||||
return [d for d in self.diagnostics if d.level == DiagnosticLevel.WARNING]
|
||||
|
||||
@property
|
||||
def notes(self) -> list:
|
||||
return [d for d in self.diagnostics if d.level == DiagnosticLevel.NOTE]
|
||||
|
||||
def filter(
|
||||
self,
|
||||
level: Optional[DiagnosticLevel] = None,
|
||||
file_pattern: Optional[str] = None,
|
||||
message_pattern: Optional[str] = None,
|
||||
code_pattern: Optional[str] = None,
|
||||
) -> list:
|
||||
"""Filter diagnostics by various criteria."""
|
||||
results = self.diagnostics
|
||||
|
||||
if level is not None:
|
||||
results = [d for d in results if d.level == level]
|
||||
|
||||
if file_pattern is not None:
|
||||
results = [d for d in results if d.matches_file_regex(file_pattern)]
|
||||
|
||||
if message_pattern is not None:
|
||||
results = [d for d in results if d.matches_message_regex(message_pattern)]
|
||||
|
||||
if code_pattern is not None:
|
||||
results = [d for d in results if d.matches_code(code_pattern)]
|
||||
|
||||
return results
|
||||
|
||||
def get_log_slice(self, line_start: int, line_end: int) -> str:
|
||||
"""Get a slice of the raw log by line numbers."""
|
||||
return "\n".join(self.raw_lines[line_start:line_end + 1])
|
||||
|
||||
def summary(self) -> dict:
|
||||
"""Return a summary of the parsed log."""
|
||||
return {
|
||||
"file": self.file_path,
|
||||
"total_diagnostics": len(self.diagnostics),
|
||||
"errors": len(self.errors),
|
||||
"warnings": len(self.warnings),
|
||||
"notes": len(self.notes),
|
||||
"error_codes": list(set(d.code for d in self.errors if d.code)),
|
||||
"warning_codes": list(set(d.code for d in self.warnings if d.code)),
|
||||
"affected_files": list(set(
|
||||
d.location.file_path for d in self.diagnostics
|
||||
if d.location
|
||||
)),
|
||||
}
|
||||
|
||||
|
||||
class CargoLogParser:
|
||||
"""
|
||||
Parser for cargo build log files.
|
||||
|
||||
Handles the standard cargo output format including:
|
||||
- error[E0XXX]: message
|
||||
- warning[lint_name]: message
|
||||
- note: message
|
||||
- help: message
|
||||
- Source code snippets with line numbers
|
||||
- Multi-line diagnostics with proper boundaries
|
||||
"""
|
||||
|
||||
# Pattern for the start of a diagnostic
|
||||
DIAGNOSTIC_HEADER = re.compile(
|
||||
r'^(error|warning|note|help|info)(\[(?P<code>[^\]]+)\])?:\s*(?P<message>.*)$'
|
||||
)
|
||||
|
||||
# Pattern for source location: --> file:line:col
|
||||
LOCATION_PATTERN = re.compile(
|
||||
r'^\s*-->\s*(?P<file>[^:]+):(?P<line>\d+):(?P<col>\d+)$'
|
||||
)
|
||||
|
||||
# Alternative location pattern: ::: file:line:col (for macro expansions)
|
||||
ALT_LOCATION_PATTERN = re.compile(
|
||||
r'^\s*:::\s*(?P<file>[^:]+):(?P<line>\d+):(?P<col>\d+)$'
|
||||
)
|
||||
|
||||
# Source code line with line number
|
||||
SOURCE_LINE_PATTERN = re.compile(
|
||||
r'^\s*(?P<line_num>\d+)\s*\|(?P<code>.*)$'
|
||||
)
|
||||
|
||||
# Continuation/annotation line (with | but no line number)
|
||||
ANNOTATION_PATTERN = re.compile(
|
||||
r'^\s*\|(?P<content>.*)$'
|
||||
)
|
||||
|
||||
# For aborting due to errors
|
||||
ABORT_PATTERN = re.compile(
|
||||
r'^(error|warning): (aborting due to|could not compile|build failed)'
|
||||
)
|
||||
|
||||
# Compilation stats
|
||||
STATS_PATTERN = re.compile(
|
||||
r'^(error|warning): `[^`]+` \(.*\) generated \d+ (error|warning)'
|
||||
)
|
||||
|
||||
def __init__(self):
|
||||
self.diagnostics = []
|
||||
self.raw_lines = []
|
||||
|
||||
def parse_file(self, file_path: str) -> ParsedLog:
|
||||
"""Parse a cargo log file."""
|
||||
with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
|
||||
content = f.read()
|
||||
return self.parse_string(content, file_path)
|
||||
|
||||
def parse_stream(
|
||||
self,
|
||||
stream: TextIO,
|
||||
source_name: str = "<stdin>",
|
||||
on_diagnostic: Optional[Callable[[Diagnostic], None]] = None,
|
||||
) -> ParsedLog:
|
||||
"""
|
||||
Parse cargo log from a stream (e.g., stdin).
|
||||
|
||||
Args:
|
||||
stream: Input stream to read from
|
||||
source_name: Name to use for the source
|
||||
on_diagnostic: Optional callback called for each diagnostic as it's parsed
|
||||
|
||||
Returns:
|
||||
ParsedLog with all parsed diagnostics
|
||||
"""
|
||||
content = stream.read()
|
||||
parsed = self.parse_string(content, source_name)
|
||||
|
||||
if on_diagnostic:
|
||||
for diag in parsed.diagnostics:
|
||||
on_diagnostic(diag)
|
||||
|
||||
return parsed
|
||||
|
||||
def parse_string(self, content: str, source_name: str = "<string>") -> ParsedLog:
|
||||
"""Parse cargo log from a string."""
|
||||
self.raw_lines = content.splitlines()
|
||||
self.diagnostics = []
|
||||
|
||||
i = 0
|
||||
while i < len(self.raw_lines):
|
||||
line = self.raw_lines[i]
|
||||
|
||||
# Skip abort/stats messages
|
||||
if self.ABORT_PATTERN.match(line) or self.STATS_PATTERN.match(line):
|
||||
i += 1
|
||||
continue
|
||||
|
||||
# Check for diagnostic header
|
||||
match = self.DIAGNOSTIC_HEADER.match(line)
|
||||
if match:
|
||||
diagnostic, end_line = self._parse_diagnostic(i)
|
||||
if diagnostic:
|
||||
self.diagnostics.append(diagnostic)
|
||||
i = end_line + 1
|
||||
else:
|
||||
i += 1
|
||||
|
||||
return ParsedLog(
|
||||
file_path=source_name,
|
||||
diagnostics=self.diagnostics,
|
||||
raw_lines=self.raw_lines
|
||||
)
|
||||
|
||||
def _parse_diagnostic(self, start_line: int) -> tuple:
|
||||
"""
|
||||
Parse a complete diagnostic block starting at start_line.
|
||||
Returns (Diagnostic, end_line_index).
|
||||
"""
|
||||
line = self.raw_lines[start_line]
|
||||
match = self.DIAGNOSTIC_HEADER.match(line)
|
||||
if not match:
|
||||
return None, start_line
|
||||
|
||||
level_str = match.group(1)
|
||||
level = DiagnosticLevel(level_str)
|
||||
code = match.group('code')
|
||||
message = match.group('message').strip()
|
||||
|
||||
diagnostic = Diagnostic(
|
||||
level=level,
|
||||
message=message,
|
||||
code=code,
|
||||
line_start=start_line,
|
||||
)
|
||||
|
||||
raw_lines = [line]
|
||||
context_lines = []
|
||||
children = []
|
||||
current_line = start_line + 1
|
||||
|
||||
# Parse the body of the diagnostic
|
||||
while current_line < len(self.raw_lines):
|
||||
line = self.raw_lines[current_line]
|
||||
|
||||
# Check if this is a new top-level diagnostic
|
||||
if self.DIAGNOSTIC_HEADER.match(line):
|
||||
# But first check if it's a child note/help (indented context)
|
||||
if not line.startswith(' ') and not self._is_child_diagnostic(line, diagnostic):
|
||||
break
|
||||
|
||||
# Check for location
|
||||
loc_match = self.LOCATION_PATTERN.match(line) or self.ALT_LOCATION_PATTERN.match(line)
|
||||
if loc_match:
|
||||
if diagnostic.location is None:
|
||||
diagnostic.location = SourceLocation(
|
||||
file_path=loc_match.group('file'),
|
||||
line=int(loc_match.group('line')),
|
||||
column=int(loc_match.group('col'))
|
||||
)
|
||||
raw_lines.append(line)
|
||||
current_line += 1
|
||||
continue
|
||||
|
||||
# Check for source code line
|
||||
src_match = self.SOURCE_LINE_PATTERN.match(line)
|
||||
if src_match:
|
||||
context_lines.append(line)
|
||||
raw_lines.append(line)
|
||||
current_line += 1
|
||||
continue
|
||||
|
||||
# Check for annotation line
|
||||
if self.ANNOTATION_PATTERN.match(line):
|
||||
context_lines.append(line)
|
||||
raw_lines.append(line)
|
||||
current_line += 1
|
||||
continue
|
||||
|
||||
# Check for child diagnostic (note: or help: within context)
|
||||
child_match = self.DIAGNOSTIC_HEADER.match(line.strip())
|
||||
if child_match and line.startswith(' '):
|
||||
child_level = DiagnosticLevel(child_match.group(1))
|
||||
child = Diagnostic(
|
||||
level=child_level,
|
||||
message=child_match.group('message').strip(),
|
||||
code=child_match.group('code'),
|
||||
line_start=current_line,
|
||||
line_end=current_line,
|
||||
)
|
||||
children.append(child)
|
||||
raw_lines.append(line)
|
||||
current_line += 1
|
||||
continue
|
||||
|
||||
# Check for = note: or = help: style
|
||||
eq_match = re.match(r'^\s*=\s*(note|help):\s*(.*)$', line)
|
||||
if eq_match:
|
||||
child = Diagnostic(
|
||||
level=DiagnosticLevel(eq_match.group(1)),
|
||||
message=eq_match.group(2).strip(),
|
||||
line_start=current_line,
|
||||
line_end=current_line,
|
||||
)
|
||||
children.append(child)
|
||||
raw_lines.append(line)
|
||||
current_line += 1
|
||||
continue
|
||||
|
||||
# Empty line might be separator or part of message
|
||||
if line.strip() == '':
|
||||
# Look ahead to see if diagnostic continues
|
||||
if current_line + 1 < len(self.raw_lines):
|
||||
next_line = self.raw_lines[current_line + 1]
|
||||
if (self.LOCATION_PATTERN.match(next_line) or
|
||||
self.SOURCE_LINE_PATTERN.match(next_line) or
|
||||
self.ANNOTATION_PATTERN.match(next_line) or
|
||||
next_line.strip().startswith('=')):
|
||||
raw_lines.append(line)
|
||||
current_line += 1
|
||||
continue
|
||||
break
|
||||
|
||||
# Other content - might be continuation of message or end
|
||||
if line.startswith(' '): # Indented content
|
||||
raw_lines.append(line)
|
||||
current_line += 1
|
||||
continue
|
||||
|
||||
# Unknown line type - end the diagnostic
|
||||
break
|
||||
|
||||
diagnostic.line_end = current_line - 1
|
||||
diagnostic.raw_text = '\n'.join(raw_lines)
|
||||
diagnostic.children = children
|
||||
diagnostic.context_lines = context_lines
|
||||
|
||||
return diagnostic, current_line - 1
|
||||
|
||||
def _is_child_diagnostic(self, line: str, parent: Diagnostic) -> bool:
|
||||
"""Check if a diagnostic line is a child of the parent."""
|
||||
# Standalone note/help that follows immediately might be related
|
||||
if line.startswith('note:') or line.startswith('help:'):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
class LogQuery:
|
||||
"""
|
||||
High-level query interface for cargo logs.
|
||||
Designed for LLM consumption with clear, structured responses.
|
||||
"""
|
||||
|
||||
def __init__(self, parsed_log: ParsedLog):
|
||||
self.log = parsed_log
|
||||
|
||||
def find_errors(
|
||||
self,
|
||||
file_pattern: Optional[str] = None,
|
||||
message_pattern: Optional[str] = None,
|
||||
code_pattern: Optional[str] = None,
|
||||
) -> list:
|
||||
"""
|
||||
Find all errors matching the given criteria.
|
||||
|
||||
Args:
|
||||
file_pattern: Regex to match file paths (e.g., "tests/.*" for test files)
|
||||
message_pattern: Regex to match error messages (e.g., "not found in")
|
||||
code_pattern: Regex to match error codes (e.g., "E0425" or "E04.*")
|
||||
|
||||
Returns:
|
||||
List of matching Diagnostic objects
|
||||
"""
|
||||
return self.log.filter(
|
||||
level=DiagnosticLevel.ERROR,
|
||||
file_pattern=file_pattern,
|
||||
message_pattern=message_pattern,
|
||||
code_pattern=code_pattern,
|
||||
)
|
||||
|
||||
def find_warnings(
|
||||
self,
|
||||
file_pattern: Optional[str] = None,
|
||||
message_pattern: Optional[str] = None,
|
||||
code_pattern: Optional[str] = None,
|
||||
) -> list:
|
||||
"""Find all warnings matching the given criteria."""
|
||||
return self.log.filter(
|
||||
level=DiagnosticLevel.WARNING,
|
||||
file_pattern=file_pattern,
|
||||
message_pattern=message_pattern,
|
||||
code_pattern=code_pattern,
|
||||
)
|
||||
|
||||
def find_by_file(self, file_pattern: str) -> list:
|
||||
"""
|
||||
Find all diagnostics for files matching the pattern.
|
||||
|
||||
Args:
|
||||
file_pattern: Regex pattern for file paths
|
||||
Examples: "src/main.rs", "tests/.*", ".*/mod.rs"
|
||||
"""
|
||||
return self.log.filter(file_pattern=file_pattern)
|
||||
|
||||
def find_by_message(self, message_pattern: str) -> list:
|
||||
"""
|
||||
Find all diagnostics with messages matching the pattern.
|
||||
|
||||
Args:
|
||||
message_pattern: Regex pattern for messages
|
||||
Examples: "not found", "unused.*variable", "lifetime"
|
||||
"""
|
||||
return self.log.filter(message_pattern=message_pattern)
|
||||
|
||||
def find_by_code(self, code_pattern: str) -> list:
|
||||
"""
|
||||
Find all diagnostics with matching error/warning codes.
|
||||
|
||||
Args:
|
||||
code_pattern: Regex for codes (e.g., "E0425", "E04.*", "unused_.*")
|
||||
"""
|
||||
return self.log.filter(code_pattern=code_pattern)
|
||||
|
||||
def get_error_boundaries(self, diagnostic: Diagnostic) -> dict:
|
||||
"""
|
||||
Get the exact boundaries of an error in the log file.
|
||||
|
||||
Returns:
|
||||
{
|
||||
"line_start": int, # Starting line in log file (0-indexed)
|
||||
"line_end": int, # Ending line in log file (0-indexed)
|
||||
"raw_text": str, # The complete raw error block
|
||||
}
|
||||
"""
|
||||
return {
|
||||
"line_start": diagnostic.line_start,
|
||||
"line_end": diagnostic.line_end,
|
||||
"raw_text": diagnostic.raw_text,
|
||||
}
|
||||
|
||||
def get_unique_error_codes(self) -> list:
|
||||
"""Get all unique error codes in the log."""
|
||||
codes = set()
|
||||
for d in self.log.diagnostics:
|
||||
if d.code:
|
||||
codes.add(d.code)
|
||||
return sorted(codes)
|
||||
|
||||
def get_affected_files(self, level: Optional[DiagnosticLevel] = None) -> list:
|
||||
"""Get all files that have diagnostics."""
|
||||
diagnostics = self.log.diagnostics
|
||||
if level:
|
||||
diagnostics = [d for d in diagnostics if d.level == level]
|
||||
|
||||
files = set()
|
||||
for d in diagnostics:
|
||||
if d.location:
|
||||
files.add(d.location.file_path)
|
||||
return sorted(files)
|
||||
|
||||
def group_by_file(
|
||||
self,
|
||||
level: Optional[DiagnosticLevel] = None,
|
||||
file_pattern: Optional[str] = None,
|
||||
) -> dict:
|
||||
"""
|
||||
Group diagnostics by file path.
|
||||
|
||||
Returns:
|
||||
{
|
||||
"src/main.rs": [Diagnostic, ...],
|
||||
"src/lib.rs": [Diagnostic, ...],
|
||||
}
|
||||
"""
|
||||
diagnostics = self.log.diagnostics
|
||||
if level:
|
||||
diagnostics = [d for d in diagnostics if d.level == level]
|
||||
if file_pattern:
|
||||
diagnostics = [d for d in diagnostics if d.matches_file_regex(file_pattern)]
|
||||
|
||||
grouped = {}
|
||||
for d in diagnostics:
|
||||
if d.location:
|
||||
file_path = d.location.file_path
|
||||
if file_path not in grouped:
|
||||
grouped[file_path] = []
|
||||
grouped[file_path].append(d)
|
||||
return grouped
|
||||
|
||||
def group_by_code(
|
||||
self,
|
||||
level: Optional[DiagnosticLevel] = None,
|
||||
) -> dict:
|
||||
"""
|
||||
Group diagnostics by error/warning code.
|
||||
|
||||
Returns:
|
||||
{
|
||||
"E0425": [Diagnostic, ...],
|
||||
"E0308": [Diagnostic, ...],
|
||||
}
|
||||
"""
|
||||
diagnostics = self.log.diagnostics
|
||||
if level:
|
||||
diagnostics = [d for d in diagnostics if d.level == level]
|
||||
|
||||
grouped = {}
|
||||
for d in diagnostics:
|
||||
code = d.code or "no_code"
|
||||
if code not in grouped:
|
||||
grouped[code] = []
|
||||
grouped[code].append(d)
|
||||
return grouped
|
||||
|
||||
def to_json(
|
||||
self,
|
||||
diagnostics: Optional[list] = None,
|
||||
include_raw: bool = True,
|
||||
indent: int = 2,
|
||||
) -> str:
|
||||
"""
|
||||
Convert diagnostics to JSON for LLM consumption.
|
||||
|
||||
Args:
|
||||
diagnostics: List of diagnostics (defaults to all)
|
||||
include_raw: Include raw log text in output
|
||||
indent: JSON indentation
|
||||
"""
|
||||
if diagnostics is None:
|
||||
diagnostics = self.log.diagnostics
|
||||
|
||||
output = {
|
||||
"summary": self.log.summary(),
|
||||
"diagnostics": []
|
||||
}
|
||||
|
||||
for d in diagnostics:
|
||||
entry = d.to_dict()
|
||||
if not include_raw:
|
||||
del entry["raw_text"]
|
||||
output["diagnostics"].append(entry)
|
||||
|
||||
return json.dumps(output, indent=indent)
|
||||
|
||||
def format_for_llm(
|
||||
self,
|
||||
diagnostics: Optional[list] = None,
|
||||
verbose: bool = False,
|
||||
) -> str:
|
||||
"""
|
||||
Format diagnostics in a readable format optimized for LLM analysis.
|
||||
|
||||
Args:
|
||||
diagnostics: List of diagnostics (defaults to all)
|
||||
verbose: Include full raw text blocks
|
||||
"""
|
||||
if diagnostics is None:
|
||||
diagnostics = self.log.diagnostics
|
||||
|
||||
if not diagnostics:
|
||||
return "No diagnostics found matching the criteria."
|
||||
|
||||
lines = []
|
||||
lines.append(f"Found {len(diagnostics)} diagnostic(s):\n")
|
||||
|
||||
for i, d in enumerate(diagnostics, 1):
|
||||
lines.append(f"{'='*60}")
|
||||
lines.append(f"[{i}] {d.level.value.upper()}", )
|
||||
if d.code:
|
||||
lines.append(f" Code: {d.code}")
|
||||
lines.append(f" Message: {d.message}")
|
||||
if d.location:
|
||||
lines.append(f" Location: {d.location}")
|
||||
lines.append(f" Log lines: {d.line_start}-{d.line_end}")
|
||||
|
||||
if d.children:
|
||||
for child in d.children:
|
||||
lines.append(f" └─ {child.level.value}: {child.message}")
|
||||
|
||||
if verbose and d.raw_text:
|
||||
lines.append("\n Raw output:")
|
||||
for raw_line in d.raw_text.split('\n'):
|
||||
lines.append(f" │ {raw_line}")
|
||||
|
||||
lines.append("")
|
||||
|
||||
return '\n'.join(lines)
|
||||
|
||||
|
||||
def main():
|
||||
"""CLI interface for the cargo log parser."""
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Parse cargo build logs and filter errors/warnings",
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
epilog="""
|
||||
Examples:
|
||||
# Show all errors
|
||||
%(prog)s build.log --errors
|
||||
|
||||
# Pipe from cargo build
|
||||
cargo build 2>&1 | %(prog)s --errors
|
||||
cargo build 2>&1 | %(prog)s --file "tests/.*"
|
||||
|
||||
# Use - for stdin explicitly
|
||||
cargo build 2>&1 | %(prog)s - --errors --file "src/.*"
|
||||
|
||||
# Find errors in test files
|
||||
%(prog)s build.log --errors --file "tests/.*"
|
||||
|
||||
# Find "not found" errors
|
||||
%(prog)s build.log --errors --message "not found"
|
||||
|
||||
# Find specific error code
|
||||
%(prog)s build.log --code "E0425"
|
||||
|
||||
# Output as JSON
|
||||
%(prog)s build.log --json
|
||||
|
||||
# Group by file
|
||||
%(prog)s build.log --group-by-file
|
||||
|
||||
# Stream mode - output each match immediately (useful with stdin)
|
||||
cargo build 2>&1 | %(prog)s --errors --stream
|
||||
"""
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"log_file",
|
||||
nargs="?",
|
||||
default="-",
|
||||
help="Path to cargo build log file (use - or omit for stdin)"
|
||||
)
|
||||
parser.add_argument("--errors", "-e", action="store_true", help="Show only errors")
|
||||
parser.add_argument("--warnings", "-w", action="store_true", help="Show only warnings")
|
||||
parser.add_argument("--file", "-f", metavar="PATTERN", help="Filter by file path regex")
|
||||
parser.add_argument("--message", "-m", metavar="PATTERN", help="Filter by message regex")
|
||||
parser.add_argument("--code", "-c", metavar="PATTERN", help="Filter by error code regex")
|
||||
parser.add_argument("--json", "-j", action="store_true", help="Output as JSON")
|
||||
parser.add_argument("--verbose", "-v", action="store_true", help="Include raw log text")
|
||||
parser.add_argument("--summary", "-s", action="store_true", help="Show summary only")
|
||||
parser.add_argument("--group-by-file", action="store_true", help="Group diagnostics by file")
|
||||
parser.add_argument("--group-by-code", action="store_true", help="Group diagnostics by error code")
|
||||
parser.add_argument("--list-codes", action="store_true", help="List all unique error codes")
|
||||
parser.add_argument("--list-files", action="store_true", help="List all affected files")
|
||||
parser.add_argument(
|
||||
"--stream",
|
||||
action="store_true",
|
||||
help="Stream mode: output each matching diagnostic immediately"
|
||||
)
|
||||
parser.add_argument(
|
||||
"--raw",
|
||||
action="store_true",
|
||||
help="Output raw log text only (useful for piping)"
|
||||
)
|
||||
parser.add_argument(
|
||||
"--passthrough",
|
||||
action="store_true",
|
||||
help="Pass through all input while also outputting matches"
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Determine level filter
|
||||
level = None
|
||||
if args.errors:
|
||||
level = DiagnosticLevel.ERROR
|
||||
elif args.warnings:
|
||||
level = DiagnosticLevel.WARNING
|
||||
|
||||
# Create filter function
|
||||
def matches_filter(diag: Diagnostic) -> bool:
|
||||
if level is not None and diag.level != level:
|
||||
return False
|
||||
if args.file and not diag.matches_file_regex(args.file):
|
||||
return False
|
||||
if args.message and not diag.matches_message_regex(args.message):
|
||||
return False
|
||||
if args.code and not diag.matches_code(args.code):
|
||||
return False
|
||||
return True
|
||||
|
||||
# Parse input (file or stdin)
|
||||
parser_instance = CargoLogParser()
|
||||
|
||||
if args.log_file == "-" or (args.log_file == "-" and not sys.stdin.isatty()):
|
||||
# Reading from stdin
|
||||
if sys.stdin.isatty() and args.log_file == "-":
|
||||
print("Reading from stdin... (Ctrl+D to end, or pipe input)", file=sys.stderr)
|
||||
|
||||
if args.passthrough:
|
||||
# Read all input, print it, then parse
|
||||
content = sys.stdin.read()
|
||||
print(content, end='')
|
||||
parsed = parser_instance.parse_string(content, "<stdin>")
|
||||
else:
|
||||
parsed = parser_instance.parse_stream(sys.stdin, "<stdin>")
|
||||
else:
|
||||
# Reading from file
|
||||
parsed = parser_instance.parse_file(args.log_file)
|
||||
|
||||
query = LogQuery(parsed)
|
||||
|
||||
# Handle special list commands
|
||||
if args.list_codes:
|
||||
codes = query.get_unique_error_codes()
|
||||
if args.json:
|
||||
print(json.dumps(codes))
|
||||
else:
|
||||
print("Unique error/warning codes:")
|
||||
for code in codes:
|
||||
print(f" {code}")
|
||||
return
|
||||
|
||||
if args.list_files:
|
||||
files = query.get_affected_files(level)
|
||||
if args.json:
|
||||
print(json.dumps(files))
|
||||
else:
|
||||
print("Affected files:")
|
||||
for f in files:
|
||||
print(f" {f}")
|
||||
return
|
||||
|
||||
if args.summary:
|
||||
summary = parsed.summary()
|
||||
if args.json:
|
||||
print(json.dumps(summary, indent=2))
|
||||
else:
|
||||
print(f"Log file: {summary['file']}")
|
||||
print(f"Total diagnostics: {summary['total_diagnostics']}")
|
||||
print(f" Errors: {summary['errors']}")
|
||||
print(f" Warnings: {summary['warnings']}")
|
||||
print(f" Notes: {summary['notes']}")
|
||||
if summary['error_codes']:
|
||||
print(f"Error codes: {', '.join(summary['error_codes'])}")
|
||||
if summary['affected_files']:
|
||||
print(f"Affected files: {len(summary['affected_files'])}")
|
||||
return
|
||||
|
||||
# Filter diagnostics
|
||||
diagnostics = [d for d in parsed.diagnostics if matches_filter(d)]
|
||||
|
||||
# Handle grouping
|
||||
if args.group_by_file:
|
||||
grouped = {}
|
||||
for d in diagnostics:
|
||||
if d.location:
|
||||
fp = d.location.file_path
|
||||
if fp not in grouped:
|
||||
grouped[fp] = []
|
||||
grouped[fp].append(d)
|
||||
|
||||
if args.json:
|
||||
output = {f: [d.to_dict() for d in diags] for f, diags in grouped.items()}
|
||||
print(json.dumps(output, indent=2))
|
||||
else:
|
||||
for file_path, diags in grouped.items():
|
||||
print(f"\n{file_path} ({len(diags)} issues):")
|
||||
for d in diags:
|
||||
print(f" - {d.summary()}")
|
||||
return
|
||||
|
||||
if args.group_by_code:
|
||||
grouped = {}
|
||||
for d in diagnostics:
|
||||
code = d.code or "no_code"
|
||||
if code not in grouped:
|
||||
grouped[code] = []
|
||||
grouped[code].append(d)
|
||||
|
||||
if args.json:
|
||||
output = {c: [d.to_dict() for d in diags] for c, diags in grouped.items()}
|
||||
print(json.dumps(output, indent=2))
|
||||
else:
|
||||
for code, diags in grouped.items():
|
||||
print(f"\n{code} ({len(diags)} occurrences):")
|
||||
for d in diags:
|
||||
loc = f" at {d.location}" if d.location else ""
|
||||
print(f" - {d.message}{loc}")
|
||||
return
|
||||
|
||||
# Output results
|
||||
if args.raw:
|
||||
# Output only raw log text for matching diagnostics
|
||||
for d in diagnostics:
|
||||
print(d.raw_text)
|
||||
print() # Blank line between
|
||||
elif args.stream or args.json:
|
||||
if args.json:
|
||||
print(query.to_json(diagnostics, include_raw=args.verbose))
|
||||
else:
|
||||
# Stream mode - one diagnostic at a time
|
||||
for d in diagnostics:
|
||||
if args.verbose:
|
||||
print(d.raw_text)
|
||||
else:
|
||||
print(d.summary())
|
||||
else:
|
||||
print(query.format_for_llm(diagnostics, verbose=args.verbose))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user