summary¶

@classmethod
def get_default(cls) -> "SummaryStrategy":
    """Get default summarization strategy."""
    return cls.EXTRACT

def get_priority(self) -> int:
    """Get priority for strategy selection."""
    priorities = {
        cls.LLM: 5,
        cls.SEMANTIC: 4,
        cls.HYBRID: 3,
        cls.EXTRACT: 2,
        cls.COMPRESS: 1,
        cls.TRUNCATE: 0,
    }
    return priorities.get(self, 0)

def truncate(self, max_tokens: int) -> "SummarySection":
    """Truncate section to fit within token limit."""
    if self.tokens <= max_tokens:
        return self

    # Calculate approximate character limit
    char_limit = (max_tokens * 4) - 50  # Leave buffer for ellipsis

    if len(self.content) <= char_limit:
        return self

    # Truncate content
    truncated_content = self.content[:char_limit] + "\n... [truncated]"

    return SummarySection(
        name=self.name,
        content=truncated_content,
        line_start=self.line_start,
        line_end=self.line_start + truncated_content.count("\n"),
        importance=self.importance,
        preserved_fully=False,
        tokens=max_tokens,
        metadata={**self.metadata, "truncated": True},
    )

def to_dict(self) -> Dict[str, Any]:
    """Convert to dictionary representation."""
    return asdict(self)

@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "SummarySection":
    """Create from dictionary."""
    return cls(**data)

def add_instruction(self, instruction: str) -> None:
    """Add an instruction for the AI about this summary."""
    if instruction and instruction not in self.instructions:
        self.instructions.append(instruction)

def add_default_instructions(self) -> None:
    """Add default instructions based on summary characteristics."""
    if self.file_path:
        self.add_instruction(
            f"This is a summary of {self.file_path} "
            f"({self.original_lines} lines → {self.summary_lines} lines)"
        )

    if self.compression_ratio < 0.5 and self.original_tokens > 0:
        self.add_instruction(
            f"Significant compression applied ({self.compression_ratio:.1%} of original). "
            f"Request full file if more detail needed."
        )

    if self.ignored_sections:
        self.add_instruction(
            f"Omitted sections: {', '.join(self.ignored_sections)}. "
            f"Request specific sections if needed."
        )

def add_metadata(self, metadata: Dict[str, Any]) -> None:
    """Add metadata about the summary."""
    self.metadata.update(metadata)

def add_section(self, section: SummarySection) -> None:
    """Add a section to the summary."""
    self.sections.append(section)
    self.summary_tokens += section.tokens
    self.token_count = self.summary_tokens

    if section.preserved_fully:
        self.preserved_sections.append(section.name)
    else:
        if section.name not in self.ignored_sections:
            self.ignored_sections.append(section.name)

def get_section(self, name: str) -> Optional[SummarySection]:
    """Get a specific section by name."""
    for section in self.sections:
        if section.name == name:
            return section
    return None

def merge_sections(self) -> str:
    """Merge all sections into final content."""
    if not self.sections:
        return self.content

    merged = []
    for section in self.sections:
        if section.name:
            merged.append(f"# {section.name}")
        merged.append(section.content)
        merged.append("")  # Empty line between sections

    self.content = "\n".join(merged)
    return self.content

def to_dict(self) -> Dict[str, Any]:
    """Convert to dictionary representation."""
    return {
        "content": self.content,
        "was_summarized": self.was_summarized,
        "original_tokens": self.original_tokens,
        "summary_tokens": self.summary_tokens,
        "original_lines": self.original_lines,
        "summary_lines": self.summary_lines,
        "preserved_sections": self.preserved_sections,
        "ignored_sections": self.ignored_sections,
        "sections": [s.to_dict() for s in self.sections],
        "strategy": self.strategy,
        "compression_ratio": self.compression_ratio,
        "instructions": self.instructions,
        "metadata": self.metadata,
        "file_path": self.file_path,
        "timestamp": self.timestamp.isoformat(),
    }

@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "FileSummary":
    """Create from dictionary."""
    if "timestamp" in data and isinstance(data["timestamp"], str):
        data["timestamp"] = datetime.fromisoformat(data["timestamp"])

    if "sections" in data:
        data["sections"] = [
            SummarySection.from_dict(s) if isinstance(s, dict) else s for s in data["sections"]
        ]

    return cls(**data)

def add_technology(self, tech: str) -> None:
    """Add a detected technology."""
    if tech and tech not in self.technologies:
        self.technologies.append(tech)

def add_framework(self, framework: str) -> None:
    """Add a detected framework."""
    if framework and framework not in self.frameworks:
        self.frameworks.append(framework)

def add_pattern(self, pattern: str) -> None:
    """Add a detected architectural pattern."""
    if pattern and pattern not in self.patterns:
        self.patterns.append(pattern)

def update_statistics(self, key: str, value: Any) -> None:
    """Update a statistic value."""
    self.statistics[key] = value

def to_markdown(self) -> str:
    """Generate markdown representation of project summary."""
    lines = [f"# Project: {self.name}", ""]

    if self.description:
        lines.extend([self.description, ""])

    # Technologies and frameworks
    if self.technologies or self.frameworks:
        lines.append("## Technologies & Frameworks")
        if self.technologies:
            lines.append(f"**Technologies:** {', '.join(self.technologies)}")
        if self.frameworks:
            lines.append(f"**Frameworks:** {', '.join(self.frameworks)}")
        lines.append("")

    # Key structure
    if self.key_directories:
        lines.append("## Key Directories")
        for dir in self.key_directories[:10]:  # Top 10
            lines.append(f"- `{dir}`")
        lines.append("")

    if self.key_files:
        lines.append("## Key Files")
        for file in self.key_files[:10]:  # Top 10
            lines.append(f"- `{file}`")
        lines.append("")

    # Statistics
    if self.statistics:
        lines.append("## Statistics")
        for key, value in self.statistics.items():
            if isinstance(value, dict):
                lines.append(f"**{key}:**")
                for k, v in value.items():
                    lines.append(f"  - {k}: {v}")
            else:
                lines.append(f"- **{key}:** {value}")
        lines.append("")

    # Patterns
    if self.patterns:
        lines.append("## Architectural Patterns")
        for pattern in self.patterns:
            lines.append(f"- {pattern}")
        lines.append("")

    return "\n".join(lines)

def to_dict(self) -> Dict[str, Any]:
    """Convert to dictionary representation."""
    return {
        "name": self.name,
        "description": self.description,
        "structure": self.structure,
        "key_files": self.key_files,
        "key_directories": self.key_directories,
        "technologies": self.technologies,
        "frameworks": self.frameworks,
        "patterns": self.patterns,
        "dependencies": self.dependencies,
        "statistics": self.statistics,
        "recent_activity": self.recent_activity,
        "team_info": self.team_info,
        "metadata": self.metadata,
        "timestamp": self.timestamp.isoformat(),
    }

@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "ProjectSummary":
    """Create from dictionary."""
    if "timestamp" in data and isinstance(data["timestamp"], str):
        data["timestamp"] = datetime.fromisoformat(data["timestamp"])
    return cls(**data)