copilot-session-tools 0.1.1__py3-none-any.whl

copilot_session_tools/html_exporter.py

@@ -0,0 +1,270 @@
+"""HTML exporter for Copilot chat sessions.
+
+Renders chat sessions as self-contained static HTML files using the same
+Jinja2 template as the web viewer, but with interactive elements (toolbar,
+AJAX, copy buttons) stripped out via the `static=True` flag.
+"""
+
+import re
+from datetime import datetime
+from pathlib import Path
+from urllib.parse import unquote
+
+import markdown
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+from markupsafe import Markup
+
+from .markdown_exporter import generate_session_filename as _md_generate_filename
+from .scanner import ChatSession
+
+# Threshold to distinguish between seconds and milliseconds timestamps.
+_MILLISECONDS_THRESHOLD = 1e12
+
+# Create a reusable markdown converter with extensions
+_md_converter = markdown.Markdown(
+    extensions=[
+        "tables",
+        "fenced_code",
+        "sane_lists",
+        "smarty",
+        "nl2br",
+    ],
+    extension_configs={
+        "smarty": {
+            "smart_dashes": True,
+            "smart_quotes": True,
+        },
+    },
+)
+
+# Regex pattern for ANSI escape codes
+_ANSI_ESCAPE_PATTERN = re.compile(
+    r"\x1b"
+    r"(?:"
+    r"\[[0-9;]*[A-Za-z]"
+    r"|"
+    r"\][^\x07]*\x07"
+    r"|"
+    r"\][^\x1b]*\x1b\\"
+    r")"
+)
+
+
+def _markdown_to_html(text: str) -> str:
+    """Convert markdown text to HTML using the markdown library."""
+    if not text:
+        return ""
+
+    text = text.replace("\r\n", "\n")
+
+    def extract_filename_from_file_uri(uri: str) -> str:
+        decoded = unquote(uri)
+        path = decoded.replace("file:///", "").split("#")[0]
+        if "/" in path:
+            return path.split("/")[-1]
+        if "\\" in path:
+            return path.split("\\")[-1]
+        return path
+
+    def replace_empty_file_link(match):
+        uri = match.group(1)
+        filename = extract_filename_from_file_uri(uri)
+        return f"`{filename}`"
+
+    text = re.sub(r"\[\]\(file://([^)]+)\)", replace_empty_file_link, text)
+    text = re.sub(r'^(Using ["""][^"""]+["""])$', r"_\1_", text, flags=re.MULTILINE)
+    text = re.sub(r"_Edited `([^`]+)`_", r"_Edited \1_", text)
+    text = re.sub(r"^(Ran terminal command:.*)$", r"_\1_", text, flags=re.MULTILINE)
+    text = re.sub(r"^((?:Now )?[Ll]et me [^:]+:)$", r"_\1_", text, flags=re.MULTILINE)
+    text = re.sub(r"^(Made changes\.)$", r"_\1_", text, flags=re.MULTILINE)
+
+    _md_converter.reset()
+    return Markup(_md_converter.convert(text))  # noqa: S704 - markdown output is intentionally rendered as HTML
+
+
+def _urldecode(text: str) -> str:
+    if not text:
+        return ""
+    return unquote(text)
+
+
+def _strip_ansi(text: str | None) -> str:
+    if not text:
+        return ""
+    return _ANSI_ESCAPE_PATTERN.sub("", text)
+
+
+def _format_timestamp(value: str) -> str:
+    if not value:
+        return ""
+    try:
+        epoch_ms = float(value)
+        epoch_s = epoch_ms / 1000
+        dt = datetime.fromtimestamp(epoch_s)
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except (ValueError, TypeError, OSError):
+        return str(value)
+
+
+def _parse_diff_stats(diff: str) -> dict:
+    if not diff:
+        return {"additions": 0, "deletions": 0}
+    additions = 0
+    deletions = 0
+    for line in diff.split("\n"):
+        if line.startswith("+++") or line.startswith("---") or line.startswith("@@"):
+            continue
+        if line.startswith("+"):
+            additions += 1
+        elif line.startswith("-"):
+            deletions += 1
+    return {"additions": additions, "deletions": deletions}
+
+
+def _extract_filename(path: str) -> str:
+    if not path:
+        return ""
+    if "/" in path:
+        return path.split("/")[-1]
+    if "\\" in path:
+        return path.split("\\")[-1]
+    return path
+
+
+def _match_tool_for_block(block_content: str, tools: list, used_indices: set) -> tuple:
+    """Match a tool invocation block content to a tool from the list."""
+    if not tools:
+        return None, used_indices
+
+    match = re.search(r"`([^`]+)`", block_content)
+    short_name = match.group(1) if match else None
+
+    if not short_name:
+        match = re.search(r"Running\s+(\S+)", block_content)
+        short_name = match.group(1) if match else None
+
+    if short_name:
+        for i, tool in enumerate(tools):
+            if i in used_indices:
+                continue
+            if short_name.lower() in tool.name.lower() or tool.name.lower().endswith(short_name.lower()):
+                used_indices = used_indices | {i}
+                return tool, used_indices
+
+    for i, tool in enumerate(tools):
+        if i not in used_indices:
+            used_indices = used_indices | {i}
+            return tool, used_indices
+
+    return None, used_indices
+
+
+def _get_jinja_env() -> Environment:
+    """Create a standalone Jinja2 environment pointing at the web templates."""
+    templates_dir = Path(__file__).parent / "web" / "templates"
+    env = Environment(
+        loader=FileSystemLoader(str(templates_dir)),
+        autoescape=select_autoescape(["html"]),
+    )
+    env.filters["markdown"] = _markdown_to_html
+    env.filters["urldecode"] = _urldecode
+    env.filters["format_timestamp"] = _format_timestamp
+    env.filters["parse_diff_stats"] = _parse_diff_stats
+    env.filters["extract_filename"] = _extract_filename
+    env.filters["strip_ansi"] = _strip_ansi
+    env.globals["match_tool_for_block"] = _match_tool_for_block
+    return env
+
+
+def _preprocess_messages(session: ChatSession) -> tuple[str | None, dict[int, dict]]:
+    """Pre-process messages to match tool invocations with content blocks.
+
+    Same logic as the webapp session_view route. Returns first user prompt
+    and a dict mapping message index to its block metadata.
+    """
+    first_user_prompt = None
+    message_metadata: dict[int, dict] = {}
+    for msg_idx, message in enumerate(session.messages):
+        if message.role == "user" and first_user_prompt is None:
+            first_user_prompt = message.content
+
+        block_tool_map = {}
+        block_cmd_map = {}
+        used_tool_indices: set = set()
+        used_cmd_indices: set = set()
+
+        for i, block in enumerate(message.content_blocks):
+            if block.kind == "toolInvocation":
+                if message.command_runs and block.content.startswith("$"):
+                    cmd_text = block.content[1:].strip()
+                    for j, cmd in enumerate(message.command_runs):
+                        if j in used_cmd_indices:
+                            continue
+                        if cmd.command and (cmd.command.startswith(cmd_text[:30]) or cmd_text[:30] in cmd.command):
+                            block_cmd_map[i] = cmd
+                            used_cmd_indices.add(j)
+                            break
+
+                if i not in block_cmd_map and message.tool_invocations:
+                    matched_tool, used_tool_indices = _match_tool_for_block(block.content, message.tool_invocations, used_tool_indices)
+                    if matched_tool:
+                        block_tool_map[i] = matched_tool
+
+        message_metadata[msg_idx] = {
+            "block_tool_map": block_tool_map,
+            "block_cmd_map": block_cmd_map,
+            "matched_tool_names": {t.name for t in block_tool_map.values()},
+            "matched_cmd_indices": used_cmd_indices,
+        }
+
+    return first_user_prompt, message_metadata
+
+
+def session_to_html(session: ChatSession) -> str:
+    """Convert a chat session to a self-contained static HTML string.
+
+    Args:
+        session: The ChatSession to convert.
+
+    Returns:
+        Complete HTML document as a string.
+    """
+    first_user_prompt, message_metadata = _preprocess_messages(session)
+    env = _get_jinja_env()
+    template = env.get_template("session.html")
+    return template.render(
+        title=session.custom_title or session.workspace_name or f"Session {session.session_id[:8]}",
+        session=session,
+        message_count=len(session.messages),
+        first_user_prompt=first_user_prompt,
+        message_metadata=message_metadata,
+        static=True,
+    )
+
+
+def export_session_to_html_file(
+    session: ChatSession,
+    output_path: Path | str,
+) -> None:
+    """Export a single session to a static HTML file.
+
+    Args:
+        session: The ChatSession to export.
+        output_path: Path to the output HTML file.
+    """
+    html = session_to_html(session)
+    Path(output_path).write_text(html, encoding="utf-8")
+
+
+def generate_session_html_filename(session: ChatSession) -> str:
+    """Generate a filename for a session's HTML export.
+
+    Args:
+        session: The ChatSession to generate a filename for.
+
+    Returns:
+        A safe filename string with .html extension.
+    """
+    # Reuse markdown filename logic but swap extension
+    md_filename = _md_generate_filename(session)
+    return md_filename.rsplit(".", 1)[0] + ".html"

copilot_session_tools/markdown_exporter.py

@@ -0,0 +1,426 @@
+"""Markdown exporter for Copilot chat sessions.
+
+Exports chat sessions to markdown format with:
+- Header block with metadata (session ID, workspace, dates)
+- Messages separated by horizontal rules
+- Message numbers and roles as bold headers
+- Tool call summaries in italics
+- Thinking block notices in italics (without the full content)
+"""
+
+from datetime import datetime
+from pathlib import Path
+from urllib.parse import unquote
+
+from .scanner import ChatMessage, ChatSession
+
+# Threshold to distinguish between seconds and milliseconds timestamps.
+# Timestamps above this value (approximately year 2001 in milliseconds) are
+# treated as milliseconds and divided by 1000 to convert to seconds.
+_MILLISECONDS_THRESHOLD = 1e12
+
+
+def _format_timestamp(value: str | int | None) -> str:
+    """Format an epoch timestamp (milliseconds) to a human-readable date string."""
+    if not value:
+        return "Unknown"
+    try:
+        # Handle both string and numeric values - float() accepts both
+        numeric_value = float(value)
+        # Check if milliseconds (common for JS timestamps)
+        if numeric_value > _MILLISECONDS_THRESHOLD:
+            numeric_value = numeric_value / 1000
+        dt = datetime.fromtimestamp(numeric_value)
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except (ValueError, TypeError, OSError):
+        # If parsing fails, return original value as string
+        return str(value)
+
+
+def _urldecode(text: str) -> str:
+    """Decode URL-encoded text (e.g., 'c%3A' -> 'c:')."""
+    if not text:
+        return ""
+    return unquote(text)
+
+
+def _format_tool_summary(message: ChatMessage, include_inputs: bool = False) -> str:
+    """Format tool invocations as an italicized summary line.
+
+    Args:
+        message: The message containing tool invocations.
+        include_inputs: If True, include tool inputs as code blocks.
+    """
+    if not message.tool_invocations:
+        return ""
+
+    tool_names = [tool.name for tool in message.tool_invocations]
+    count = len(tool_names)
+
+    if count == 1:
+        summary = f"\n\n*Used tool: {tool_names[0]}*"
+    elif count <= 3:
+        summary = f"\n\n*Used tools: {', '.join(tool_names)}*"
+    else:
+        summary = f"\n\n*Used {count} tools: {', '.join(tool_names[:3])}, ...*"
+
+    if include_inputs:
+        for tool in message.tool_invocations:
+            if tool.input:
+                summary += f"\n\n**{tool.name} input:**\n```\n{tool.input}\n```"
+
+    return summary
+
+
+def _format_file_changes_summary(message: ChatMessage, include_diffs: bool = False) -> str:
+    """Format file changes as an italicized summary line.
+
+    Args:
+        message: The message containing file changes.
+        include_diffs: If True, include file diffs as code blocks.
+    """
+    if not message.file_changes:
+        return ""
+
+    paths = [change.path for change in message.file_changes]
+    count = len(paths)
+
+    if count == 1:
+        summary = f"\n\n*Changed file: {paths[0]}*"
+    elif count <= 3:
+        summary = f"\n\n*Changed files: {', '.join(paths)}*"
+    else:
+        summary = f"\n\n*Changed {count} files: {', '.join(paths[:3])}, ...*"
+
+    if include_diffs:
+        for change in message.file_changes:
+            if change.diff:
+                summary += f"\n\n**{change.path}:**\n```diff\n{change.diff}\n```"
+
+    return summary
+
+
+def _format_command_runs_summary(message: ChatMessage) -> str:
+    """Format command runs as an italicized summary line."""
+    if not message.command_runs:
+        return ""
+
+    count = len(message.command_runs)
+
+    if count == 1:
+        cmd = message.command_runs[0]
+        if cmd.title:
+            cmd_display = cmd.title
+        else:
+            cmd_display = cmd.command[:50] + "..." if len(cmd.command) > 50 else cmd.command
+        return f"\n\n*Ran command: `{cmd_display}`*"
+    else:
+        return f"\n\n*Ran {count} commands*"
+
+
+def _had_thinking_content(message: ChatMessage) -> bool:
+    """Check if the message had any thinking blocks."""
+    if not message.content_blocks:
+        return False
+    return any(block.kind == "thinking" for block in message.content_blocks)
+
+
+def _has_inline_tool_blocks(message: ChatMessage) -> bool:
+    """Check if the message has inline tool invocation blocks.
+
+    When tools are rendered inline (VSCode-style), we don't need to add
+    a separate tool summary at the end of the message.
+    """
+    if not message.content_blocks:
+        return False
+    return any(block.kind == "toolInvocation" for block in message.content_blocks)
+
+
+def _format_message_content(message: ChatMessage, include_thinking: bool = False) -> str:
+    """Format message content, optionally including thinking blocks.
+
+    Args:
+        message: The ChatMessage to format.
+        include_thinking: If True, include thinking block content. If False, show
+                         a notice that thinking occurred but omit the content.
+
+    Returns:
+        Formatted message content as a string.
+    """
+    parts = []
+
+    # Check if there was thinking content
+    had_thinking = _had_thinking_content(message)
+
+    if message.content_blocks:
+        # Use structured content blocks
+        for block in message.content_blocks:
+            if block.kind == "thinking":
+                if include_thinking:
+                    # Include the actual thinking content in a blockquote
+                    parts.append(f"> **Thinking:**\n> {block.content.replace(chr(10), chr(10) + '> ')}")
+                # If not including, we'll add a notice at the start
+                continue
+            elif block.kind == "toolInvocation":
+                # For command runs, description holds the human-readable title
+                # (content starts with "$ " and is the raw command)
+                # For regular tools, content is already the pretty invocation message
+                if block.description and block.content.startswith("$ "):
+                    display = block.description
+                else:
+                    display = block.content.strip()
+                if display:
+                    parts.append(f"*{display}*")
+            else:
+                # Only add non-empty text blocks
+                if block.content.strip():
+                    parts.append(block.content)
+    else:
+        # Fall back to flat content
+        if message.content.strip():
+            parts.append(message.content)
+
+    content = "\n\n".join(parts)
+
+    # Post-process to normalize formatting patterns
+    import re
+
+    # "*Creating [](file://...)*" -> "*Creating filename*" (extract leaf name, keep italics, remove link)
+    content = re.sub(r"\*Creating \[\]\(file://[^)]+/([^/)]+)\)\*", r"*Creating \1*", content)
+
+    # "*Reading [](file://...)*" -> "*Reading filename*" (extract leaf name, keep italics, remove link)
+    content = re.sub(r"\*Reading \[\]\(file://[^)]+/([^/)]+)\)\*", r"*Reading \1*", content)
+
+    # "*Edited `filename`*" -> "*Edited filename*" (remove backticks within italics)
+    content = re.sub(r"\*Edited `([^`]+)`\*", r"*Edited \1*", content)
+
+    # Add thinking notice if there was thinking content (and not already included)
+    if had_thinking and not include_thinking:
+        content = "*[Was thinking...]*\n\n" + content
+
+    return content
+
+
+def session_to_markdown(
+    session: ChatSession,
+    include_diffs: bool = False,
+    include_tool_inputs: bool = False,
+    include_thinking: bool = False,
+) -> str:
+    """Convert a chat session to markdown format.
+
+    Args:
+        session: The ChatSession to convert.
+        include_diffs: If True, include file diffs as code blocks.
+        include_tool_inputs: If True, include tool inputs as code blocks.
+        include_thinking: If True, include thinking block content. If False (default),
+                         show a notice that thinking occurred but omit the content.
+
+    Returns:
+        Markdown string representation of the session.
+    """
+    lines = []
+
+    # Header block with metadata
+    lines.append("# Chat Session")
+    lines.append("")
+
+    # Session title/name
+    if session.custom_title:
+        lines.append(f"**Title:** {session.custom_title}")
+    elif session.workspace_name:
+        lines.append(f"**Workspace:** {session.workspace_name}")
+    else:
+        lines.append(f"**Session:** {session.session_id[:8]}...")
+
+    lines.append("")
+
+    # Metadata in a clear format
+    lines.append("## Metadata")
+    lines.append("")
+    lines.append(f"- **Session ID:** `{session.session_id}`")
+
+    if session.workspace_name:
+        lines.append(f"- **Workspace:** {session.workspace_name}")
+
+    if session.workspace_path:
+        decoded_path = _urldecode(session.workspace_path)
+        lines.append(f"- **Path:** `{decoded_path}`")
+
+    if session.created_at:
+        lines.append(f"- **Created:** {_format_timestamp(session.created_at)}")
+
+    if session.updated_at:
+        lines.append(f"- **Updated:** {_format_timestamp(session.updated_at)}")
+
+    lines.append(f"- **Edition:** `{session.vscode_edition}`")
+    lines.append(f"- **Messages:** {len(session.messages)}")
+
+    if session.requester_username:
+        lines.append(f"- **User:** {session.requester_username}")
+
+    if session.responder_username:
+        lines.append(f"- **Assistant:** {session.responder_username}")
+
+    lines.append("")
+    lines.append("---")
+    lines.append("")
+
+    # Messages
+    for i, message in enumerate(session.messages, 1):
+        msg_md = message_to_markdown(
+            message,
+            message_number=i,
+            include_diffs=include_diffs,
+            include_tool_inputs=include_tool_inputs,
+            include_thinking=include_thinking,
+        )
+        lines.append(msg_md)
+
+    return "\n".join(lines)
+
+
+def message_to_markdown(
+    message: ChatMessage,
+    message_number: int = 0,
+    include_diffs: bool = False,
+    include_tool_inputs: bool = False,
+    include_thinking: bool = False,
+) -> str:
+    """Convert a single message to markdown format.
+
+    Args:
+        message: The ChatMessage to convert.
+        message_number: The 1-based message number (0 means don't include header).
+        include_diffs: If True, include file diffs as code blocks.
+        include_tool_inputs: If True, include tool inputs as code blocks.
+        include_thinking: If True, include thinking block content.
+
+    Returns:
+        Markdown string representation of the message.
+    """
+    lines = []
+
+    # Message header: number and role (if message_number > 0)
+    if message_number > 0:
+        role_display = message.role.upper()
+        lines.append(f"## Message {message_number}: **{role_display}**")
+        lines.append("")
+
+    # Timestamp if available
+    if message.timestamp:
+        lines.append(f"*{_format_timestamp(message.timestamp)}*")
+        lines.append("")
+
+    # Content (optionally including thinking blocks)
+    content = _format_message_content(message, include_thinking=include_thinking)
+    lines.append(content)
+
+    # Check if tools are rendered inline via content blocks
+    # If so, skip the separate tool/command summaries to avoid duplication
+    has_inline_tools = _has_inline_tool_blocks(message)
+
+    if not has_inline_tools:
+        # Tool invocations summary (in italics, with optional inputs)
+        tool_summary = _format_tool_summary(message, include_inputs=include_tool_inputs)
+        if tool_summary:
+            lines.append(tool_summary)
+
+        # Command runs summary (in italics)
+        cmd_summary = _format_command_runs_summary(message)
+        if cmd_summary:
+            lines.append(cmd_summary)
+
+    # File changes summary (in italics, with optional diffs) - always include
+    file_summary = _format_file_changes_summary(message, include_diffs=include_diffs)
+    if file_summary:
+        lines.append(file_summary)
+
+    lines.append("")
+    lines.append("---")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def export_session_to_file(
+    session: ChatSession,
+    output_path: Path | str,
+    include_diffs: bool = False,
+    include_tool_inputs: bool = False,
+    include_thinking: bool = False,
+) -> None:
+    """Export a single session to a markdown file.
+
+    Args:
+        session: The ChatSession to export.
+        output_path: Path to the output markdown file.
+        include_diffs: If True, include file diffs as code blocks.
+        include_tool_inputs: If True, include tool inputs as code blocks.
+        include_thinking: If True, include thinking block content in the export.
+    """
+    markdown = session_to_markdown(
+        session,
+        include_diffs=include_diffs,
+        include_tool_inputs=include_tool_inputs,
+        include_thinking=include_thinking,
+    )
+    Path(output_path).write_text(markdown, encoding="utf-8")
+
+
+def _sanitize_filename(name: str, max_length: int = 50) -> str:
+    """Sanitize a string to be safe for use as a filename.
+
+    Replaces any characters that are not alphanumeric, hyphen, underscore,
+    or period with underscores. Also limits the length.
+
+    Args:
+        name: The string to sanitize.
+        max_length: Maximum length of the resulting string.
+
+    Returns:
+        A filesystem-safe string.
+    """
+    safe_name = "".join(c if c.isalnum() or c in ("-", "_", ".") else "_" for c in name)
+    return safe_name[:max_length]
+
+
+def generate_session_filename(session: ChatSession) -> str:
+    """Generate a filename for a session's markdown export.
+
+    Args:
+        session: The ChatSession to generate a filename for.
+
+    Returns:
+        A safe filename string.
+    """
+    # Use custom title, workspace name, or session ID prefix
+    if session.custom_title:
+        name = session.custom_title
+    elif session.workspace_name:
+        name = session.workspace_name
+    else:
+        name = session.session_id[:16]
+
+    # Add date if available
+    date_str = ""
+    if session.created_at:
+        try:
+            ts = session.created_at
+            if isinstance(ts, str):
+                ts = float(ts)
+            if ts > _MILLISECONDS_THRESHOLD:
+                ts = ts / 1000
+            date_str = datetime.fromtimestamp(ts).strftime("%Y%m%d")
+        except (ValueError, TypeError, OSError):
+            pass
+
+    # Create safe filename
+    safe_name = _sanitize_filename(name)
+
+    if date_str:
+        filename = f"{date_str}_{safe_name}_{session.session_id[:8]}.md"
+    else:
+        filename = f"{safe_name}_{session.session_id[:8]}.md"
+
+    return filename