Casely

{
  "skill_name": "casely",
  "evals": [
    {
      "id": 1,
      "prompt": "Initialize a new testing project for the 'Payments' feature. I have requirement documents and some previous test case examples.",
      "expected_output": "Skill creates the standard directory structure under projects/Payments/, checks the environment (venv and libraries), and guides the user on where to place files.",
      "files": []
    },
    {
      "id": 2,
      "prompt": "I've uploaded my files and run the parser. Now create a style guide based on my parsed examples in the 'processed' folder.",
      "expected_output": "Skill analyzes the Markdown tables in the processed folder that originated from examples, extracts column structure and writing style, and generates a comprehensive test_style_guide.md.",
      "files": []
    },
    {
      "id": 3,
      "prompt": "Based on the requirements in the 'processed' folder and use the 'test_style_guide.md', generate a suite of atomic functional test cases.",
      "expected_output": "Skill identifies features from requirements, applies the style guide formatting, and generates atomic test cases (one scenario per row) in the results directory.",
      "files": []
    },
    {
      "id": 4,
      "prompt": "Everything looks good. Export the generated test cases to a formatted Excel file for my TMS.",
      "expected_output": "Skill executes the export script to convert Markdown tables in the results folder into a professional .xlsx file in the exports folder.",
      "files": []
    }
  ]
}

"""
CaselyParser — Document-to-Markdown converter for LLM analysis.

Uses docling to convert PDF, DOCX, PPTX, XLSX, HTML and other formats
to clean Markdown while preserving structure, tables and text.

Usage:
    python casely_parser.py <input_dir> <output_dir>

    Or programmatically:
        from casely_parser import DocumentParser
        dp = DocumentParser()
        result = dp.parse_folder("input/requirements", "processed/requirements")
"""

import sys
import logging
import argparse
from pathlib import Path
from typing import List, Optional, cast
from dataclasses import dataclass

try:
    from docling.document_converter import DocumentConverter
except ImportError:
    print("❌ Error: docling is not installed. Install with: pip install docling")
    sys.exit(1)

# Logger configuration
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)


@dataclass
class ParsingResult:
    """Result of a folder parsing operation"""
    processed: int
    skipped: int
    errors: List[str]


class DocumentParser:
    """
    Document parser based on docling.

    Supported formats:
        PDF, DOCX, PPTX, XLSX, HTML, HTM, MD, TXT, PNG, JPG, JPEG, TIFF, TIF
    """

    SUPPORTED_EXTENSIONS = {
        '.pdf', '.docx', '.pptx', '.xlsx', '.html',
        '.htm', '.md', '.txt', '.png', '.jpg',
        '.jpeg', '.tiff', '.tif'
    }

    def __init__(self, config: Optional[dict] = None):
        """
        Initialize the parser.

        Args:
            config: Configuration dictionary (encoding, overwrite, etc.)
        """
        logger.info("🚀 Initializing Docling parser")
        self.converter = DocumentConverter()
        self.config = config or {}

    def parse_file(self, file_path: Path, output_dir: Path) -> bool:
        """
        Parse a single file to Markdown.

        Args:
            file_path: Path to the source file
            output_dir: Directory to save the result

        Returns:
            True if file was successfully converted, False if skipped
        """
        output_file = output_dir / f"_parsed_{file_path.stem}.md"

        if output_file.exists():
            logger.info(f"⏭️ Already processed: {output_file.name}")
            return False

        try:
            logger.info(f"🔄 Parsing: {file_path.name}")
            result = self.converter.convert(str(file_path))
            md_content = result.document.export_to_markdown()
            output_file.write_text(md_content, encoding='utf-8')
            logger.info(f"✅ Success: {file_path.name} → {output_file.name}")
            return True
        except Exception as e:
            logger.error(f"❌ Error in {file_path.name}: {e}")
            raise

    def parse_folder(self, raw_dir: str, ready_dir: str) -> ParsingResult:
        """
        Parses all supported files from raw_dir into ready_dir.

        Saves as _parsed_{name}.md. Skips already processed files.

        Args:
            raw_dir: Source directory
            ready_dir: Output directory

        Returns:
            ParsingResult containing counts and errors
        """
        raw_path = Path(raw_dir)
        ready_path = Path(ready_dir)
        ready_path.mkdir(parents=True, exist_ok=True)

        if not raw_path.exists():
            logger.error(f"❌ Directory not found: {raw_dir}")
            return ParsingResult(0, 0, [f"Directory not found: {raw_dir}"])

        result = ParsingResult(processed=0, skipped=0, errors=[])

        for file_path in raw_path.iterdir():
            if not (file_path.is_file() and
                    file_path.suffix.lower() in self.SUPPORTED_EXTENSIONS):
                logger.debug(f"⏭️ Unsupported format: {file_path.name}")
                continue

            try:
                success = self.parse_file(file_path, ready_path)
                if success:
                    result.processed += 1
                else:
                    result.skipped += 1
            except Exception as e:
                result.errors.append(f"{file_path.name}: {str(e)}")

        logger.info(f"🎉 Folder complete: {raw_dir} → {ready_dir} "
                    f"({result.processed} new, {result.skipped} skipped)")
        if result.errors:
            logger.warning(f"⚠️ Errors in {len(result.errors)} files")

        return result

    @classmethod
    def get_supported_formats(cls) -> str:
        """Returns string of supported extensions"""
        return ', '.join(sorted(cls.SUPPORTED_EXTENSIONS))


def find_latest_project() -> Optional[Path]:
    """Find the most recently modified project directory."""
    projects_dir = Path("projects")
    if not projects_dir.exists():
        return None
    
    subdirs = [d for d in projects_dir.iterdir() if d.is_dir()]
    if not subdirs:
        return None
    
    return max(subdirs, key=lambda d: d.stat().st_mtime)


def main():
    """CLI interface for the parser"""
    arg_parser = argparse.ArgumentParser(
        description='CaselyParser — Document to Markdown converter'
    )
    arg_parser.add_argument('input_dir', nargs='?', help='Source directory')
    arg_parser.add_argument('output_dir', nargs='?', help='Output directory (Markdown)')
    args = arg_parser.parse_args()

    logger.info("📋 Supported formats: %s", DocumentParser.get_supported_formats())
    parser = DocumentParser()

    # Case 1: Manual paths provided
    if args.input_dir and args.output_dir:
        parser.parse_folder(args.input_dir, args.output_dir)
        return

    # Case 2: Auto-detect latest project
    latest_project_opt = find_latest_project()
    if not latest_project_opt:
        logger.error("❌ No project found and no paths provided.")
        sys.exit(1)

    latest_project = cast(Path, latest_project_opt)
    logger.info(f"📂 Auto-detected project: {latest_project.name}")

    # List of sub-folders to process
    sub_tasks = [
        ("input/requirements", "processed/requirements"),
        ("input/examples", "processed/examples")
    ]

    total_processed = 0
    for inp_sub, out_sub in sub_tasks:
        inp_path = latest_project / inp_sub
        out_path = latest_project / out_sub
        
        if inp_path.exists():
            logger.info(f"🔎 Scanning {inp_sub}...")
            result = parser.parse_folder(str(inp_path), str(out_path))
            total_processed += result.processed

    if total_processed == 0:
        logger.info("ℹ️ No new files to process.")
    else:
        logger.info(f"✅ Finished! Total new files: {total_processed}")


if __name__ == '__main__':
    main()

"""
Casely Export Module — converts Markdown test case tables into individual Excel files.
"""

import re
import sys
import argparse
from pathlib import Path
from typing import Optional, List, Tuple

try:
    from openpyxl import Workbook
    from openpyxl.worksheet.worksheet import Worksheet
    from openpyxl.styles import Font, Alignment
    from openpyxl.utils import get_column_letter
except ImportError:
    print("Error: openpyxl is required. Install it with: pip install openpyxl")
    sys.exit(1)

MIN_COL_WIDTH = 10
MAX_COL_WIDTH = 60


def _split_table_row(line: str) -> List[str]:
    """Split a Markdown table row into individual cell values."""
    raw_parts = re.split(r'(?<!\\)\|', line)
    start: int = 1 if line.startswith('|') else 0
    end: int = -1 if line.endswith('|') else len(raw_parts)

    result: List[str] = []
    raw_len = len(raw_parts)
    for i in range(start, int(end) if end >= 0 else raw_len + int(end)):
        cell = raw_parts[i]
        if cell is not None:
            result.append(cell.strip().replace(r'\|', '|'))
    return result


def parse_md_table(md_content: str) -> Tuple[List[str], List[List[str]]]:
    """Parse a Markdown table into headers and data rows."""
    lines: List[str] = [
        line.strip()
        for line in md_content.strip().split('\n')
        if line.strip().startswith('|')
    ]
    if len(lines) < 2:
        return [], []

    headers: List[str] = _split_table_row(lines[0])
    rows: List[List[str]] = []

    for line in lines[1:]:
        # Skip separator rows like |---|---|
        if re.match(r'^\|[\s\-:|]+\|$', line):
            continue

        row: List[str] = _split_table_row(line)
        if not row:
            continue

        # Pad short rows with empty strings
        while len(row) < len(headers):
            row.append('')

        # Trim extra columns
        rows.append(row[0:len(headers)])

    return headers, rows


def export_to_xlsx(results_dir: str, output_path: str) -> None:
    """Convert each Markdown test case to a separate Excel file."""
    results_path = Path(results_dir)
    out_dir = Path(output_path)

    if not results_path.exists():
        print(f"Error: Results directory not found: {results_dir}")
        sys.exit(1)

    # Create the export directory if it does not exist
    out_dir.mkdir(parents=True, exist_ok=True)

    md_files = sorted(results_path.glob('*.md'))
    if not md_files:
        print(f"Warning: No .md files found in {results_dir}")
        return

    for md_file in md_files:
        headers, rows = parse_md_table(md_file.read_text(encoding='utf-8'))
        if not headers:
            print(f"Skipping {md_file.name}: No table found.")
            continue

        # Create a new workbook for each file
        wb = Workbook()
        ws_opt = wb.active
        if ws_opt is None:
            print(f"Skipping {md_file.name}: Failed to create worksheet.")
            continue
        ws: Worksheet = ws_opt  # type: ignore[assignment]
        ws.title = "Test Case"

        # Write headers
        for col_idx, header in enumerate(headers, 1):
            ws.cell(row=1, column=col_idx, value=header)

        # Write data rows
        for row_idx, row in enumerate(rows, 2):
            for col_idx, value in enumerate(row, 1):
                clean_value = value.replace('<br>', '\n').replace('<BR>', '\n') if value else ''
                cell = ws.cell(row=row_idx, column=col_idx, value=clean_value)
                cell.alignment = Alignment(wrap_text=True, vertical='top')

        # Style headers: bold + center
        header_font = Font(bold=True)
        for col_idx in range(1, len(headers) + 1):
            header_cell = ws.cell(row=1, column=col_idx)
            header_cell.font = header_font
            header_cell.alignment = Alignment(horizontal='center', vertical='center')

        # Auto-fit column widths
        for col_idx in range(1, len(headers) + 1):
            max_len = len(str(ws.cell(row=1, column=col_idx).value or ''))
            total_rows = len(rows)
            for row_idx in range(2, total_rows + 2):
                cell_val = str(ws.cell(row=row_idx, column=col_idx).value or '')
                # For multiline cells, use the longest line
                for line in cell_val.split('\n'):
                    max_len = max(max_len, len(line))
            col_letter = get_column_letter(col_idx)
            width = min(max(max_len + 2, MIN_COL_WIDTH), MAX_COL_WIDTH)
            ws.column_dimensions[col_letter].width = width

        # Save with the same name but .xlsx extension
        dest_file = out_dir / f"{md_file.stem}.xlsx"
        wb.save(str(dest_file))
        print(f"Exported: {dest_file.name}")



def find_latest_project() -> Optional[Path]:
    """Find the most recently modified project directory."""
    projects_dir = Path("projects")
    if not projects_dir.exists():
        return None

    subdirs = [d for d in projects_dir.iterdir() if d.is_dir()]
    if not subdirs:
        return None

    return max(subdirs, key=lambda d: d.stat().st_mtime)


def main() -> None:
    """CLI interface for the exporter."""
    arg_parser = argparse.ArgumentParser(
        description='Casely Export — Markdown to Excel converter'
    )
    arg_parser.add_argument('results_dir', nargs='?', help='Path to results MD files')
    arg_parser.add_argument('output_path', nargs='?', help='Path to export XLSX files')
    args = arg_parser.parse_args()

    results_dir: Optional[str] = args.results_dir
    output_path: Optional[str] = args.output_path

    # If arguments are not provided, try to find the project automatically
    if not results_dir or not output_path:
        latest = find_latest_project()
        if latest is not None:
            results_dir = str(latest / "results")
            output_path = str(latest / "exports")
            print(f"Auto-detected project: {latest.name}")
        else:
            print("Error: No paths provided and no projects found in 'projects/' directory.")
            sys.exit(1)

    export_to_xlsx(results_dir, output_path)


if __name__ == '__main__':
    main()